New DeepEquals for JsonDocument and JsonElement (#25)

* Add default DeepEquals comparison
* Add DeepEquals to JsonElement and JsonDocument
* Refactor deep equals
* Move node tests to a new directory
* Add tests for JsonElement
* Add tests for JsonDocument
* Paper work for 1.3.0

Author: weichch

Benchmark.md

@@ -15,10 +15,10 @@ BenchmarkDotNet=v0.13.1, OS=Windows 10.0.19043.1645 (21H1/May2021Update)
 
 ## Comparison Modes
 
-|   Method | FileSize |     Mean |   Median |      Min |      Max |      P80 |      P95 | Allocated |
-|--------- |--------- |---------:|---------:|---------:|---------:|---------:|---------:|----------:|
-|  RawText |    Small | 100.9 μs | 100.3 μs | 98.36 μs | 105.7 μs | 102.0 μs | 104.9 μs |     77 KB |
-| Semantic |    Small | 102.2 μs | 101.9 μs | 99.37 μs | 107.0 μs | 103.1 μs | 105.6 μs |     76 KB |
+|   Method | FileSize |      Mean |    Median |       Min |       Max |       P80 |       P95 | Allocated |
+|--------- |--------- |----------:|----------:|----------:|----------:|----------:|----------:|----------:|
+|  RawText |    Small |  94.05 μs |  94.09 μs |  93.13 μs |  95.36 μs |  94.35 μs |  94.80 μs |     75 KB |
+| Semantic |    Small | 104.65 μs | 104.27 μs | 102.67 μs | 107.86 μs | 105.55 μs | 107.76 μs |     75 KB |
 
 \* _All benchmarks are generated using the same small JSON object used in the **System.Text.Json vs Newtonsoft Json** section below, with array move detection enabled (default)._
 
@@ -28,23 +28,25 @@ BenchmarkDotNet=v0.13.1, OS=Windows 10.0.19043.1645 (21H1/May2021Update)
 
 |             Method | FileSize |        Mean |      Median |         Min |         Max |         P80 |         P95 | Allocated |
 |------------------- |--------- |------------:|------------:|------------:|------------:|------------:|------------:|----------:|
-|     **SystemTextJson** |    **Small** |    **79.09 μs** |    **78.25 μs** |    **75.72 μs** |    **84.89 μs** |    **81.91 μs** |    **84.16 μs** |     **66 KB** |
-|            JsonNet |    Small |    91.98 μs |    92.15 μs |    90.06 μs |    94.50 μs |    92.77 μs |    93.78 μs |    132 KB |
-| SystemTextJson_Rfc |    Small |    94.88 μs |    94.74 μs |    93.34 μs |    97.80 μs |    95.69 μs |    96.86 μs |     87 KB |
-|        JsonNet_Rfc |    Small |   106.41 μs |   106.01 μs |   103.58 μs |   110.69 μs |   107.38 μs |   109.75 μs |    150 KB |
-|     **SystemTextJson** |    **Large** | **3,717.44 μs** | **3,700.53 μs** | **3,577.00 μs** | **3,913.15 μs** | **3,766.22 μs** | **3,901.23 μs** |  **3,258 KB** |
-|            JsonNet |    Large | 4,104.18 μs | 4,085.60 μs | 3,922.80 μs | 4,343.10 μs | 4,199.56 μs | 4,273.98 μs |  4,386 KB |
-| SystemTextJson_Rfc |    Large | 4,900.93 μs | 4,890.86 μs | 4,772.28 μs | 5,128.16 μs | 4,958.30 μs | 5,021.94 μs |  4,561 KB |
-|        JsonNet_Rfc |    Large | 5,569.83 μs | 5,535.12 μs | 5,354.93 μs | 5,976.46 μs | 5,682.46 μs | 5,822.63 μs |  6,147 KB |
+|     **SystemTextJson** |    **Small** |    **76.93 μs** |    **76.88 μs** |    **75.62 μs** |    **79.28 μs** |    **77.43 μs** |    **78.11 μs** |     **67 KB** |
+|            JsonNet |    Small |    84.97 μs |    84.75 μs |    83.72 μs |    87.68 μs |    85.64 μs |    86.38 μs |    132 KB |
+| SystemTextJson_Rfc |    Small |    91.88 μs |    91.71 μs |    90.70 μs |    95.01 μs |    92.37 μs |    94.37 μs |     89 KB |
+|        JsonNet_Rfc |    Small |   102.15 μs |   102.10 μs |   100.49 μs |   104.37 μs |   102.58 μs |   103.29 μs |    150 KB |
+|     **SystemTextJson** |    **Large** | **3,739.64 μs** | **3,734.25 μs** | **3,626.78 μs** | **3,902.76 μs** | **3,781.22 μs** | **3,844.92 μs** |  **3,365 KB** |
+|            JsonNet |    Large | 3,846.70 μs | 3,850.62 μs | 3,760.20 μs | 3,917.07 μs | 3,887.43 μs | 3,896.80 μs |  4,386 KB |
+| SystemTextJson_Rfc |    Large | 4,897.11 μs | 4,868.30 μs | 4,722.99 μs | 5,196.12 μs | 4,930.06 μs | 5,159.49 μs |  4,667 KB |
+|        JsonNet_Rfc |    Large | 5,260.99 μs | 5,249.26 μs | 5,121.82 μs | 5,487.74 μs | 5,322.84 μs | 5,460.47 μs |  6,147 KB |
 
 ### DeepEquals
 
-|         Method | FileSize |        Mean |      Median |         Min |         Max |         P80 |         P95 | Allocated |
-|--------------- |--------- |------------:|------------:|------------:|------------:|------------:|------------:|----------:|
-| **SystemTextJson** |    **Small** |    **52.92 μs** |    **52.89 μs** |    **52.00 μs** |    **54.46 μs** |    **53.31 μs** |    **53.90 μs** |     **39 KB** |
-|        JsonNet |    Small |    58.82 μs |    58.77 μs |    57.78 μs |    60.41 μs |    59.16 μs |    59.74 μs |     91 KB |
-| **SystemTextJson** |    **Large** | **2,099.55 μs** | **2,090.78 μs** | **1,963.92 μs** | **2,302.56 μs** | **2,161.80 μs** | **2,223.10 μs** |  **1,631 KB** |
-|        JsonNet |    Large | 2,296.54 μs | 2,293.76 μs | 2,239.68 μs | 2,393.52 μs | 2,323.09 μs | 2,378.88 μs |  2,426 KB |
+|                  Method | FileSize |        Mean |      Median |         Min |         Max |         P80 |         P95 | Allocated |
+|------------------------ |--------- |------------:|------------:|------------:|------------:|------------:|------------:|----------:|
+|     **SystemTextJson_Node** |    **Small** |    **55.10 μs** |    **54.96 μs** |    **54.14 μs** |    **56.93 μs** |    **55.49 μs** |    **56.57 μs** |     **38 KB** |
+| SystemTextJson_Document |    Small |    40.63 μs |    40.58 μs |    40.08 μs |    41.27 μs |    40.80 μs |    41.12 μs |     26 KB |
+|                 JsonNet |    Small |    57.84 μs |    57.62 μs |    57.17 μs |    59.40 μs |    58.07 μs |    58.98 μs |     91 KB |
+|     **SystemTextJson_Node** |    **Large** | **2,143.34 μs** | **2,125.71 μs** | **2,048.46 μs** | **2,328.43 μs** | **2,194.35 μs** | **2,266.60 μs** |  **1,571 KB** |
+| SystemTextJson_Document |    Large | 1,372.31 μs | 1,371.00 μs | 1,352.61 μs | 1,391.00 μs | 1,379.30 μs | 1,388.30 μs |    920 KB |
+|                 JsonNet |    Large | 2,208.71 μs | 2,209.77 μs | 2,182.51 μs | 2,246.30 μs | 2,223.80 μs | 2,235.96 μs |  2,426 KB |
 
 ### Patch
 

README.md

@@ -8,39 +8,40 @@ High-performance, low-allocating JSON object diff and patch extension for System
 
 - Compatible with [jsondiffpatch delta format](https://github.com/benjamine/jsondiffpatch/blob/master/docs/deltas.md)
 - Support generating patch document in RFC 6902 JSON Patch format
-- Target latest .NET Standard and .NET Framework 4.6.1 (for legacy apps) and leverage latest .NET features
+- Target latest **.NET Standard** and **.NET Framework 4.6.1** (for legacy apps) and leverage latest .NET features
 - Alternative to [jsondiffpatch.net](https://github.com/wbish/jsondiffpatch.net) which is based on Newtonsoft.Json
 - Fast large JSON document diffing with less memory consumption (see [benchmark](https://github.com/weichch/system-text-json-jsondiffpatch/blob/main/Benchmark.md))
 - Support smart array diffing (e.g. move detect) using LCS (Longest Common Subsequence) and custom array item matcher
 - _(Only when not using RFC 6902 format)_ Support diffing long text using [google-diff-match-patch](http://code.google.com/p/google-diff-match-patch/), or write your own diff algorithm
-- Bonus `JsonNode.DeepClone` and `JsonNode.DeepEquals` methods
-- Bouns [`JsonValueComparer`](https://github.com/weichch/system-text-json-jsondiffpatch/blob/main/src/SystemTextJson.JsonDiffPatch/JsonValueComparer.cs) that implements semantic comparison of two `JsonValue` objects (including `JsonValue` backed by `JsonElement`)
+- Bonus `DeepEquals` method for comparing `JsonDocument`, `JsonElement` and `JsonNode`
+- Bonus `DeepClone` method
+- Bonus [`JsonValueComparer`](https://github.com/weichch/system-text-json-jsondiffpatch/blob/main/src/SystemTextJson.JsonDiffPatch/JsonValueComparer.cs) that implements semantic comparison of two `JsonValue` objects
 - JSON assert for xUnit, MSTest v2 and NUnit with customizable delta output
 
 ## Install
 
 #### JsonDiffPatch
 
 ```
-Install-Package SystemTextJson.JsonDiffPatch
+PM> Install-Package SystemTextJson.JsonDiffPatch
 ```
 
 #### xUnit Assert
 
 ```
-Install-Package SystemTextJson.JsonDiffPatch.Xunit
+PM> Install-Package SystemTextJson.JsonDiffPatch.Xunit
 ```
 
 #### MSTest v2 Assert
 
 ```
-Install-Package SystemTextJson.JsonDiffPatch.MSTest
+PM> Install-Package SystemTextJson.JsonDiffPatch.MSTest
 ```
 
 #### NUnit Assert
 
 ```
-Install-Package SystemTextJson.JsonDiffPatch.NUnit
+PM> Install-Package SystemTextJson.JsonDiffPatch.NUnit
 ```
 
 ## Usage
@@ -51,80 +52,91 @@ Install-Package SystemTextJson.JsonDiffPatch.NUnit
 // Diff JsonNode
 var node1 = JsonNode.Parse("{\"foo\":\"bar\"}");
 var node2 = JsonNode.Parse("{\"baz\":\"qux\", \"foo\":\"bar\"}");
-JsonNode? diff = node1.Diff(node2);
+var diff = node1.Diff(node2);
 // Diff with options
-JsonNode? diff = node1.Diff(node2, new JsonDiffOptions
+var diff = node1.Diff(node2, new JsonDiffOptions
 {
     JsonElementComparison = JsonElementComparison.Semantic
 });
 // Diff and convert delta into RFC 6902 JSON Patch format
-JsonNode? diff = node1.Diff(node2, new JsonPatchDeltaFormatter());
+var diff = node1.Diff(node2, new JsonPatchDeltaFormatter());
 // Diff JSON files
-JsonNode? diff = JsonDiffPatcher.DiffFile(file1, file2);
+var diff = JsonDiffPatcher.DiffFile(file1, file2);
 // Diff Span<byte>
-JsonNode? diff = JsonDiffPatcher.Diff(span1, span2);
+var diff = JsonDiffPatcher.Diff(span1, span2);
 // Diff streams
-JsonNode? diff = JsonDiffPatcher.Diff(stream1, stream2);
+var diff = JsonDiffPatcher.Diff(stream1, stream2);
 // Diff JSON strings
-JsonNode? diff = JsonDiffPatcher.Diff(json1, json2);
+var diff = JsonDiffPatcher.Diff(json1, json2);
 // Diff JSON readers
-JsonNode? diff = JsonDiffPatcher.Diff(ref reader1, ref reader2);
+var diff = JsonDiffPatcher.Diff(ref reader1, ref reader2);
 ```
 
-### DeepClone
+### Patch & Unpatch
 
 ```csharp
-var node = JsonNode.Parse("{\"foo\":\"bar\"}");
-JsonNode? cloned = node.DeepClone();
+var node1 = JsonNode.Parse("{\"foo\":\"bar\"}");
+var node2 = JsonNode.Parse("{\"baz\":\"qux\", \"foo\":\"bar\"}");
+var diff = node1.Diff(node2);
+// In-place patch
+JsonDiffPatcher.Patch(ref node1, diff);
+// Clone & patch
+var patched = node1.PatchNew(diff);
+// In-place unpatch
+JsonDiffPatcher.ReversePatch(ref node1, diff);
+// Clone & unpatch
+var patched = node1.ReversePatchNew(diff);
 ```
 
 ### DeepEquals
 
 ```csharp
-var node1 = JsonNode.Parse("{\"foo\":1.0}");
-var node2 = JsonNode.Parse("{\"foo\":1}");
-// equal is false
-bool equal = node1.DeepEquals(node2);
-// semanticEqual is true
-bool semanticEqual = node1.DeepEquals(node2, JsonElementComparison.Semantic);
-```
-
-### Semantic Value Comparison
-```csharp
-var node1 = JsonNode.Parse("\"2019-11-27\"");
-var node2 = JsonNode.Parse("\"2019-11-27T00:00:00.000\"");
-// dateCompare is 0
-var dateCompare = JsonValueComparer.Compare(node1, node2);
+// JsonDocument
+var doc1 = JsonDocument.Parse("{\"foo\":1}");
+var doc2 = JsonDocument.Parse("{\"foo\":1.0}");
+var equal = doc1.DeepEquals(doc2);
+var textEqual = doc1.DeepEquals(doc2, JsonElementComparison.RawText);
+var semanticEqual = doc1.DeepEquals(doc2, JsonElementComparison.Semantic);
 
-var node3 = JsonNode.Parse("1");
-var node4 = JsonNode.Parse("1.00");
-// numCompare is 0
-var numCompare = JsonValueComparer.Compare(node3, node4);
+// JsonNode
+var node1 = JsonNode.Parse("{\"foo\":1}");
+var node2 = JsonNode.Parse("{\"foo\":1.0}");
+var equal = node1.DeepEquals(node2);
+var textEqual = node1.DeepEquals(node2, JsonElementComparison.RawText);
+var semanticEqual = node1.DeepEquals(node2, JsonElementComparison.Semantic);
 ```
 
-### Patch & Unpatch
+### DeepClone
 
 ```csharp
-var node1 = JsonNode.Parse("{\"foo\":\"bar\"}");
-var node2 = JsonNode.Parse("{\"baz\":\"qux\", \"foo\":\"bar\"}");
-JsonNode? diff = node1.Diff(node2);
-// In-place patch
-JsonDiffPatcher.Patch(ref node1, diff);
-// Clone & patch
-node1.PatchNew(diff);
-// In-place unpatch
-JsonDiffPatcher.ReversePatch(ref node1, diff);
-// Clone & unpatch
-node1.ReversePatchNew(diff);
+var node = JsonNode.Parse("{\"foo\":\"bar\"}");
+var cloned = node.DeepClone();
 ```
 
 ### Default Options
 
 ```csharp
+// Default diff options
 JsonDiffPatcher.DefaultOptions = () => new JsonDiffOptions
 {
     JsonElementComparison = JsonElementComparison.Semantic
 };
+
+// Default comparison mode for DeepEquals
+JsonDiffPatcher.DefaultComparison = JsonElementComparison.Semantic;
+```
+
+### Semantic Value Comparison
+```csharp
+var node1 = JsonNode.Parse("\"2019-11-27\"");
+var node2 = JsonNode.Parse("\"2019-11-27T00:00:00.000\"");
+// dateCompare is 0
+var dateCompare = JsonValueComparer.Compare(node1, node2);
+
+var node3 = JsonNode.Parse("1");
+var node4 = JsonNode.Parse("1.00");
+// numCompare is 0
+var numCompare = JsonValueComparer.Compare(node3, node4);
 ```
 
 ### Assert (Unit Testing)
@@ -178,4 +190,4 @@ Delta:
 
 ## Benchmark
 
-[Benchmark results](https://github.com/weichch/system-text-json-jsondiffpatch/blob/main/Benchmark.md) were generated using example objects [here](https://github.com/weichch/system-text-json-jsondiffpatch/tree/main/test/Examples) and benchmark tests [here](https://github.com/weichch/system-text-json-jsondiffpatch/tree/main/test/SystemTextJson.JsonDiffPatch.Benchmark/).
+See detailed [benchmark results](https://github.com/weichch/system-text-json-jsondiffpatch/blob/main/Benchmark.md).

ReleaseNotes.md

@@ -1,5 +1,12 @@
 # Release Notes
 
+## 1.3.0
+
+- **Added `DeepEquals` implementation for `JsonDocument` and `JsonElement`**
+- Performance improvements in raw text comparison mode
+- Removed unnecessary allocation when default diff option is used
+- Removed one `DeepEquals` overload that was accidentally exposed as a public method
+
 ## 1.2.0
 
 - Major performance improvement in array comparison

src/SystemTextJson.JsonDiffPatch/Diffs/JsonDiffOptions.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Runtime.CompilerServices;
 using System.Text.Json.JsonDiffPatch.Diffs;
 using System.Text.Json.Nodes;
 
@@ -9,8 +10,7 @@ namespace System.Text.Json.JsonDiffPatch
     /// </summary>
     public class JsonDiffOptions
     {
-        internal static readonly JsonDiffOptions Default = new();
-        private JsonComparerOptions _comparerOptions;
+        private JsonElementComparison? _jsonElementComparison;
 
         /// <summary>
         /// Specifies whether to suppress detect array move. Default value is <c>false</c>.
@@ -49,22 +49,18 @@ public class JsonDiffOptions
         /// <summary>
         /// Gets or sets the mode to compare two <see cref="JsonElement"/> instances.
         /// </summary>
-        public JsonElementComparison JsonElementComparison { get; set; }
+        public JsonElementComparison JsonElementComparison
+        {
+            get => _jsonElementComparison ?? JsonDiffPatcher.DefaultComparison;
+            set => _jsonElementComparison = value;
+        }
 
         /// <summary>
         /// Gets or sets the <see cref="JsonValue"/> comparer.
         /// </summary>
         public IEqualityComparer<JsonValue>? ValueComparer { get; set; }
 
-        internal ref JsonComparerOptions CreateComparerOptions()
-        {
-            if (JsonElementComparison != _comparerOptions.JsonElementComparison
-                || !ReferenceEquals(ValueComparer, _comparerOptions.ValueComparer))
-            {
-                _comparerOptions = new JsonComparerOptions(JsonElementComparison, ValueComparer);
-            }
-
-            return ref _comparerOptions;
-        }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal JsonComparerOptions CreateComparerOptions() => new(JsonElementComparison, ValueComparer);
     }
 }