Fixed WithDefaultOptions logic where text nodes was compared by a naive node comparer, not text comparer

Author: egil

src/AngleSharp.Diffing.Tests/DiffBuilderTest.cs

@@ -51,18 +51,18 @@ public void Test6()
             diffs.ShouldNotBeEmpty();
         }
 
-        //[Fact(DisplayName = "Calling Build() with DefaultOptions() returns expected diffs")]
-        //public void Test7()
-        //{
-        //    var control = "<h1>Hello World</h1>";
-        //    var test = "<h1>Hello world</h1>";
+        [Fact(DisplayName = "Calling Build() with DefaultOptions() returns expected diffs")]
+        public void Test7()
+        {
+            var control = "<h1>Hello World</h1>";
+            var test = "<h1>Hello world</h1>";
 
-        //    var diffs = new DiffBuilder(DefaultStrategy)
-        //        .Compare(control)
-        //        .WithTest(test)
-        //        .Build();
+            var diffs = new DiffBuilder(DefaultStrategy)
+                .Compare(control)
+                .WithTest(test)
+                .Build();
 
-        //    diffs.ShouldNotBeEmpty();
-        //}
+            diffs.ShouldNotBeEmpty();
+        }
     }
 }

src/AngleSharp.Diffing.Tests/DiffingStrategyPipelineBuilderTest.cs

@@ -35,7 +35,7 @@ public void Test3()
             Should.Throw<InvalidOperationException>(
                 () => new DiffingStrategyPipelineBuilder()
                 .WithClassAttributeComparer()
-                .WithNodeNameComparer()
+                .WithElementComparer()
                 .Build());
         }
 

src/AngleSharp.Diffing.Tests/Strategies/NodeStrategies/NodeComparerTest.cs

@@ -1,4 +1,5 @@
 using AngleSharp.Diffing.Core;
+using AngleSharp.Diffing.Strategies.ElementStrategies;
 using Shouldly;
 using Xunit;
 
@@ -14,7 +15,7 @@ public NodeComparerTest(DiffingTestFixture fixture) : base(fixture)
         public void Test001()
         {
             var comparison = ToComparison("<p>", "<p>");
-            NodeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Same);
+            ElementComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Same);
         }
 
         [Theory(DisplayName = "When control and test nodes have the a different type and name, the result is Different")]
@@ -25,7 +26,7 @@ public void Test001()
         public void Test002(string controlHtml, string testHtml)
         {
             var comparison = ToComparison(controlHtml, testHtml);
-            NodeComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Different);
+            ElementComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Different);
         }
     }
 }

src/AngleSharp.Diffing/DiffBuilder.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using AngleSharp;
 using AngleSharp.Dom;
 using AngleSharp.Html.Parser;
 using AngleSharp.Diffing.Core;

src/AngleSharp.Diffing/Strategies/CommentStrategies/CommentComparer.cs

@@ -0,0 +1,16 @@
+using AngleSharp.Diffing.Core;
+using AngleSharp.Dom;
+
+namespace AngleSharp.Diffing.Strategies.CommentStrategies
+{
+    public static class CommentComparer
+    {
+        public static CompareResult Compare(in Comparison comparison, CompareResult currentDecision)
+        {
+            if (currentDecision.IsSameOrSkip()) return currentDecision;
+            return comparison.Control.Node.NodeType == NodeType.Comment && comparison.AreNodeTypesEqual()
+                ? CompareResult.Same
+                : CompareResult.Different;
+        }
+    }
+}

src/AngleSharp.Diffing/Strategies/CommentStrategies/DiffingStrategyPipelineBuilderExtensions.cs

@@ -12,5 +12,14 @@ public static IDiffingStrategyPipelineBuilder IgnoreComments(this IDiffingStrate
             builder.WithFilter(IgnoreCommentsFilter.Filter, true);
             return builder;
         }
+
+        /// <summary>
+        /// Enables the basic comment comparer, that checks if two nodes are comment nodes.
+        /// </summary>
+        public static IDiffingStrategyPipelineBuilder WithCommentComparer(this IDiffingStrategyPipelineBuilder builder)
+        {
+            builder.WithComparer(CommentComparer.Compare, isSpecializedComparer: false);
+            return builder;
+        }
     }
 }

src/AngleSharp.Diffing/Strategies/DiffingStrategyPipelineBuilderExtensions.cs

@@ -16,7 +16,7 @@ public static IDiffingStrategyPipelineBuilder WithDefaultOptions(this IDiffingSt
                 .WithSearchingNodeMatcher()
                 .WithCssSelectorMatcher()
                 .WithAttributeNameMatcher()
-                .WithNodeNameComparer()
+                .WithElementComparer()                
                 .WithIgnoreElementSupport()
                 .WithStyleSheetComparer()
                 .WithTextComparer(WhitespaceOption.Normalize, ignoreCase: false)

src/AngleSharp.Diffing/Strategies/ElementStrategies/DiffingStrategyPipelineBuilderExtensions.cs

@@ -4,6 +4,15 @@ namespace AngleSharp.Diffing
 {
     public static partial class DiffingStrategyPipelineBuilderExtensions
     {
+        /// <summary>
+        /// Enables the basic element comparer, that checks if two nodes are element nodes and have the same name.
+        /// </summary>
+        public static IDiffingStrategyPipelineBuilder WithElementComparer(this IDiffingStrategyPipelineBuilder builder)
+        {
+            builder.WithComparer(ElementComparer.Compare, isSpecializedComparer: false);
+            return builder;
+        }
+
         /// <summary>
         /// Enables the CSS-selector matcher strategy during diffing.
         /// </summary>

src/AngleSharp.Diffing/Strategies/ElementStrategies/ElementComparer.cs

@@ -0,0 +1,16 @@
+using AngleSharp.Diffing.Core;
+using AngleSharp.Dom;
+
+namespace AngleSharp.Diffing.Strategies.ElementStrategies
+{
+    public static class ElementComparer
+    {
+        public static CompareResult Compare(in Comparison comparison, CompareResult currentDecision)
+        {
+            if (currentDecision.IsSameOrSkip()) return currentDecision;
+            return comparison.Control.Node.NodeType == NodeType.Element && comparison.AreNodeTypesEqual()
+                ? CompareResult.Same
+                : CompareResult.Different;
+        }
+    }
+}

src/AngleSharp.Diffing/Strategies/NodeStrategies/DiffingStrategyPipelineBuilderExtensions.cs

@@ -1,3 +1,5 @@
+using AngleSharp.Diffing.Strategies.CommentStrategies;
+using AngleSharp.Diffing.Strategies.ElementStrategies;
 using AngleSharp.Diffing.Strategies.NodeStrategies;
 
 namespace AngleSharp.Diffing
@@ -21,14 +23,5 @@ public static IDiffingStrategyPipelineBuilder WithSearchingNodeMatcher(this IDif
             builder.WithMatcher(ForwardSearchingNodeMatcher.Match, isSpecializedMatcher: false);
             return builder;
         }
-
-        /// <summary>
-        /// Enables the basic node compare strategy during diffing.
-        /// </summary>
-        public static IDiffingStrategyPipelineBuilder WithNodeNameComparer(this IDiffingStrategyPipelineBuilder builder)
-        {
-            builder.WithComparer(NodeComparer.Compare, isSpecializedComparer: false);
-            return builder;
-        }
     }
 }