Add merge to provide a way to create moves.

Author: Lattyware

src/Json/Diff.elm

@@ -24,8 +24,11 @@ This uses a relatively expensive, but not perfect weight function to decide what
 the JSON to a string and looks at the length), but it should give pretty reasonable results most of the time. If you
 want something more efficient or accurate you can use [`diffWithCustomWeight`](Json.Diff#diffWithCustomWeight).
 
-Note that this is a simple diff that never produces moves or copies, and as such the patches will be inefficient if
-those are common operations in your case.
+This won't produce moves in the patch. If you use [`invertibleDiff`](Json.Diff#invertibleDiff) and
+[`Invertible.merge`](Json.Patch.Invertible#merge) you can merge adds and removes of the same value into moves.
+
+Note that this diff doesn't search for duplicated values and so will never produces copies, and as such the patches
+will not be concise if that is a common operation in your case.
 
 -}
 diff : Json.Value -> Json.Value -> JsonP.Patch

src/Json/Patch/Invertible.elm

@@ -1,6 +1,6 @@
 module Json.Patch.Invertible exposing
     ( Patch, Operation(..)
-    , invert, apply
+    , apply, invert, merge
     , toPatch, toMinimalPatch, fromPatch
     )
 
@@ -14,7 +14,7 @@ module Json.Patch.Invertible exposing
 
 # Operations
 
-@docs invert, apply
+@docs apply, invert, merge
 
 
 # Compatibility
@@ -26,6 +26,7 @@ module Json.Patch.Invertible exposing
 import Json.Decode as Json
 import Json.Patch as Json
 import Json.Pointer as Json
+import Set
 
 
 {-| A list of invertible [`Operation`](Json.Patch.Invertible#Operation])s that are performed one after another.
@@ -75,6 +76,78 @@ apply =
     toMinimalPatch >> Json.apply
 
 
+{-| Take a patch and merge any `Remove` and `Add` operations that have the same values into single `Move` options.
+
+The resulting patch should always do the same thing as it did before, but may be smaller.
+
+-}
+merge : Patch -> Patch
+merge patch =
+    let
+        filterAdd op =
+            case op of
+                Add pointer value ->
+                    Just ( pointer, value )
+
+                _ ->
+                    Nothing
+
+        filterRemove op =
+            case op of
+                Remove pointer value ->
+                    Just ( pointer, value )
+
+                _ ->
+                    Nothing
+
+        adds =
+            patch |> List.filterMap filterAdd
+
+        removes =
+            patch |> List.filterMap filterRemove
+
+        pairs =
+            adds |> List.concatMap (\a -> removes |> List.map (\r -> ( a, r )))
+
+        isMove ( ( _, av ), ( _, rv ) ) =
+            av == rv && rv == av
+
+        moves =
+            pairs |> List.filter isMove
+
+        filterUsed ( ( ap, av ), ( rp, rv ) ) ( filtered, usedAdds, usedRemoves ) =
+            if (usedAdds |> Set.member ap) || (usedRemoves |> Set.member rp) then
+                ( filtered, usedAdds, usedRemoves )
+
+            else
+                ( ( ( ap, av ), ( rp, rv ) ) :: filtered, usedAdds |> Set.insert ap, usedRemoves |> Set.insert rp )
+
+        ( filteredMoves, _, _ ) =
+            moves |> List.foldr filterUsed ( [], Set.empty, Set.empty )
+
+        replace op =
+            case op of
+                Add pointer value ->
+                    if filteredMoves |> List.any (\( ( p, _ ), _ ) -> p == pointer) then
+                        Nothing
+
+                    else
+                        Add pointer value |> Just
+
+                Remove pointer value ->
+                    case filteredMoves |> List.filter (\( _, ( p, _ ) ) -> p == pointer) |> List.head of
+                        Just ( ( ap, _ ), ( rp, _ ) ) ->
+                            Move rp ap |> Just
+
+                        Nothing ->
+                            Remove pointer value |> Just
+
+                _ ->
+                    op |> Just
+    in
+    patch |> List.filterMap replace
+
+
 {-| Create a normal patch from an invertible one.
 
 Note that this patch would still be invertible, you are just losing the type guarantee of that (i.e: you could run

tests/Cases.elm

@@ -344,6 +344,21 @@ cases =
                 "a": {"a": { "b" : { "c" : { "1" : 1, "2": 2, "3": 3 } } } },
                 "b": {"a": { "b" : { "c" : { "x" : 1, "y": 2, "z": 3 } } } },
                 "patch": [{"op": "replace", "path": "/a/b/c", "value": { "x" : 1, "y": 2, "z": 3 }}]
+            },
+            {
+                "description": "add and remove the same value",
+                "a": {"a": 1, "b": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"},
+                "b": {"d": 1, "b": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"},
+                "patch": [{"op": "remove", "path": "/a"}, {"op": "add", "path": "/d", "value": 1}]
+            },
+            {
+                "description": "add and remove the same value multiple times",
+                "a": {"a": 1, "b": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "c": 1},
+                "b": {"d": 1, "b": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "e": 1},
+                "patch": [
+                    {"op": "remove", "path": "/a"}, {"op": "remove", "path": "/c"},
+                    {"op": "add", "path": "/d", "value": 1}, {"op": "add", "path": "/e", "value": 1}
+                ]
             }
         ]
     """

tests/Invertible.elm

@@ -1,4 +1,4 @@
-module Invertible exposing (suite)
+module Invertible exposing (invertSuite, mergeSuite)
 
 import Cases exposing (TestCase, suiteUsingTestCases)
 import Expect exposing (Expectation)
@@ -9,14 +9,14 @@ import Json.Patch.Invertible as Invertable
 import Test exposing (..)
 
 
-suite : Test
-suite =
-    suiteUsingTestCases "Invertible correctly handles " toTest
+invertSuite : Test
+invertSuite =
+    suiteUsingTestCases "Patch, invert, patch has the same result for: " invertTest
 
 
-toTest : TestCase -> Test
-toTest { a, b } =
-    test ("Patch and back works | a: " ++ (a |> JsonE.encode 0) ++ " | b: " ++ (b |> JsonE.encode 0))
+invertTest : TestCase -> Test
+invertTest { a, b } =
+    test ("a: " ++ (a |> JsonE.encode 0) ++ " | b: " ++ (b |> JsonE.encode 0))
         (\_ ->
             let
                 diff =
@@ -34,6 +34,36 @@ toTest { a, b } =
         )
 
 
+mergeSuite : Test
+mergeSuite =
+    suiteUsingTestCases "Patch and Merge Patch have the same result for:" mergeTest
+
+
+mergeTest : TestCase -> Test
+mergeTest { a, b } =
+    test ("a: " ++ (a |> JsonE.encode 0) ++ " | b: " ++ (b |> JsonE.encode 0))
+        (\_ ->
+            let
+                diff =
+                    Diff.invertibleDiff a b
+
+                mergedDiff =
+                    diff |> Invertable.merge
+            in
+            case a |> Invertable.apply diff of
+                Ok patched ->
+                    case a |> Invertable.apply mergedDiff of
+                        Ok mergePatched ->
+                            expectJsonEqual patched mergePatched
+
+                        Err err ->
+                            Expect.fail err
+
+                Err err ->
+                    Expect.fail err
+        )
+
+
 expectJsonEqual : Json.Value -> Json.Value -> Expectation
 expectJsonEqual a =
     Expect.all