ADD: diff:ignoreAttributes element comparer

grishat · grishat · commit a8263ce39a60 · 2021-09-07T11:11:24.000+05:00
diff --git a/src/AngleSharp.Diffing.Tests/Core/HtmlDifferenceEngineTest.cs b/src/AngleSharp.Diffing.Tests/Core/HtmlDifferenceEngineTest.cs
@@ -374,6 +374,23 @@ public void Test3()
             results.ShouldBeEmpty();
         }
 
+        [Fact(DisplayName = "When comparer returns SkipAttributes from an element comparison, attributes are not compared")]
+        public void Test4()
+        {
+            var sut = CreateHtmlDiffer(
+                nodeMatcher: OneToOneNodeListMatcher,
+                nodeFilter: NoneNodeFilter,
+                nodeComparer: c => CompareResult.Same | CompareResult.SkipAttributes,
+                attrMatcher: AttributeNameMatcher,
+                attrFilter: NoneAttrFilter,
+                attrComparer: SameResultAttrComparer
+                );
+
+            var results = sut.Compare(ToNodeList(@"<p id=""foo""></p>"), ToNodeList(@"<p id=""bar"" unexpected></p>"));
+
+            results.ShouldBeEmpty();
+        }
+
         #region NodeFilters
         private static FilterDecision NoneNodeFilter(ComparisonSource source) => FilterDecision.Keep;
         private static FilterDecision RemoveCommentNodeFilter(ComparisonSource source) => source.Node.NodeType == NodeType.Comment ? FilterDecision.Exclude : FilterDecision.Keep;
diff --git a/src/AngleSharp.Diffing.Tests/DiffBuilderTest.cs b/src/AngleSharp.Diffing.Tests/DiffBuilderTest.cs
@@ -89,5 +89,41 @@ public void Test004()
             nodeComparerCalled.ShouldBeTrue();
             attrComparerCalled.ShouldBeTrue();
         }
+
+        [Theory(DisplayName = "When a control element has 'diff:ignoreChildren', calling Build() with DefaultOptions() returns empty diffs")]
+        [InlineData(@"<p diff:ignoreChildren>hello <em>world</em></p>",
+                         @"<p>world says <strong>hello</strong></p>")]
+        [InlineData(@"<p diff:ignoreChildren>hello</p>",
+                         @"<p>world says <strong>hello</strong></p>")]
+        [InlineData(@"<p diff:ignoreChildren>hello <em>world</em></p>",
+                         @"<p>world says</p>")]
+        public void Test005(string control, string test)
+        {
+            var diffs = DiffBuilder
+                .Compare(control)
+                .WithTest(test)
+                .Build()
+                .ToList();
+
+            diffs.ShouldBeEmpty();
+        }
+
+        [Theory(DisplayName = "When a control element has 'diff:ignoreAttributes', calling Build() with DefaultOptions() returns empty diffs")]
+        [InlineData(@"<p id=""foo"" diff:ignoreAttributes></p>",
+                         @"<p id=""bar""></p>")]
+        [InlineData(@"<p diff:ignoreAttributes></p>",
+                         @"<p unexpected></p>")]
+        [InlineData(@"<p id=""foo"" diff:ignoreAttributes></p>",
+                         @"<p></p>")]
+        public void Test006(string control, string test)
+        {
+            var diffs = DiffBuilder
+                .Compare(control)
+                .WithTest(test)
+                .Build()
+                .ToList();
+
+            diffs.ShouldBeEmpty();
+        }
     }
 }
diff --git a/src/AngleSharp.Diffing.Tests/Strategies/ElementStrategies/IgnoreAttributesElementComparerTest.cs b/src/AngleSharp.Diffing.Tests/Strategies/ElementStrategies/IgnoreAttributesElementComparerTest.cs
@@ -0,0 +1,44 @@
+using System.Linq;
+
+using AngleSharp.Diffing.Core;
+
+using Shouldly;
+
+using Xunit;
+
+namespace AngleSharp.Diffing.Strategies.ElementStrategies
+{
+    public class IgnoreAttributesElementComparerTest : DiffingTestBase
+    {
+        public IgnoreAttributesElementComparerTest(DiffingTestFixture fixture) : base(fixture)
+        {
+        }
+
+        [Theory(DisplayName = "When a control element does not contain the 'diff:ignoreAttributes' attribute or it is 'diff:ignoreAttributes=false', the current decision is returned")]
+        [InlineData(@"<p></p>")]
+        [InlineData(@"<p diff:ignoreAttributes=""false""></p>")]
+        [InlineData(@"<p diff:ignoreAttributes=""FALSE""></p>")]
+        [InlineData(@"<p diff:ignoreAttributes=""faLsE""></p>")]
+        public void Test001(string controlHtml)
+        {
+            var comparison = ToComparison(controlHtml, "<p></p>");
+
+            IgnoreAttributesElementComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Different);
+            IgnoreAttributesElementComparer.Compare(comparison, CompareResult.Same).ShouldBe(CompareResult.Same);
+            IgnoreAttributesElementComparer.Compare(comparison, CompareResult.Skip).ShouldBe(CompareResult.Skip);
+        }
+
+        [Theory(DisplayName = "When a control element has 'diff:ignoreAttributes' attribute, CompareResult.SkipAttributes flag is returned")]
+        [InlineData(@"<p diff:ignoreAttributes></p>")]
+        [InlineData(@"<p diff:ignoreAttributes=""true""></p>")]
+        [InlineData(@"<p diff:ignoreAttributes=""TRUE""></p>")]
+        [InlineData(@"<p diff:ignoreAttributes=""TrUe""></p>")]
+        public void Test002(string controlHtml)
+        {
+            var comparison = ToComparison(controlHtml, "<p></p>");
+
+            IgnoreAttributesElementComparer.Compare(comparison, CompareResult.Same).ShouldBe(CompareResult.Same | CompareResult.SkipAttributes);
+            IgnoreAttributesElementComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Different | CompareResult.SkipAttributes);
+        }
+    }
+}
diff --git a/src/AngleSharp.Diffing.Tests/Strategies/ElementStrategies/IgnoreChildrenElementComparerTest.cs b/src/AngleSharp.Diffing.Tests/Strategies/ElementStrategies/IgnoreChildrenElementComparerTest.cs
@@ -21,7 +21,7 @@ public IgnoreChildrenElementComparerTest(DiffingTestFixture fixture) : base(fixt
         [InlineData(@"<p diff:ignoreChildren=""faLsE""></p>")]
         public void Test001(string controlHtml)
         {
-            var comparison = ToComparison(controlHtml, "<p><em></em></p>");
+            var comparison = ToComparison(controlHtml, "<p></p>");
 
             IgnoreChildrenElementComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Different);
             IgnoreChildrenElementComparer.Compare(comparison, CompareResult.Same).ShouldBe(CompareResult.Same);
@@ -35,28 +35,10 @@ public void Test001(string controlHtml)
         [InlineData(@"<p diff:ignoreChildren=""TrUe""></p>")]
         public void Test002(string controlHtml)
         {
-            var comparison = ToComparison(controlHtml, "<p><em></em></p>");
+            var comparison = ToComparison(controlHtml, "<p></p>");
 
             IgnoreChildrenElementComparer.Compare(comparison, CompareResult.Same).ShouldBe(CompareResult.Same | CompareResult.SkipChildren);
             IgnoreChildrenElementComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Different | CompareResult.SkipChildren);
         }
-
-        [Theory(DisplayName = "When a control element has 'diff:ignoreChildren', calling Build() with DefaultOptions() returns empty diffs")]
-        [InlineData(@"<p diff:ignoreChildren>hello <em>world</em></p>",
-                         @"<p>world says <strong>hello</strong></p>")]
-        [InlineData(@"<p diff:ignoreChildren>hello</p>",
-                         @"<p>world says <strong>hello</strong></p>")]
-        [InlineData(@"<p diff:ignoreChildren>hello <em>world</em></p>",
-                         @"<p>world says</p>")]
-        public void Test004(string control, string test)
-        {
-            var diffs = DiffBuilder
-                .Compare(control)
-                .WithTest(test)
-                .Build()
-                .ToList();
-
-            diffs.ShouldBeEmpty();
-        }
     }
 }
diff --git a/src/AngleSharp.Diffing/Core/CompareResult.cs b/src/AngleSharp.Diffing/Core/CompareResult.cs
@@ -24,6 +24,10 @@ public enum CompareResult
         /// Use when the comparison should skip any child-nodes.
         /// </summary>
         SkipChildren = 8,
+        /// <summary>
+        /// Use when the comparison should skip any attributes.
+        /// </summary>
+        SkipAttributes = 16,
     }
 
     /// <summary>
diff --git a/src/AngleSharp.Diffing/Core/HtmlDifferenceEngine.cs b/src/AngleSharp.Diffing/Core/HtmlDifferenceEngine.cs
@@ -113,7 +113,8 @@ private IEnumerable<IDiff> CompareElement(in Comparison comparison)
 
             if (compareRes != CompareResult.Skip)
             {
-                result.AddRange(CompareElementAttributes(comparison));
+                if (!compareRes.HasFlag(CompareResult.SkipAttributes))
+                    result.AddRange(CompareElementAttributes(comparison));
                 if (!compareRes.HasFlag(CompareResult.SkipChildren))
                     result.AddRange(CompareChildNodes(comparison));
             }
diff --git a/src/AngleSharp.Diffing/Strategies/DiffingStrategyPipelineBuilderExtensions.cs b/src/AngleSharp.Diffing/Strategies/DiffingStrategyPipelineBuilderExtensions.cs
@@ -19,13 +19,15 @@ public static IDiffingStrategyCollection AddDefaultOptions(this IDiffingStrategy
                 .AddAttributeNameMatcher()
                 .AddElementComparer()
                 .AddIgnoreElementSupport()
-                .AddIgnoreChildrenElementSupport()
                 .AddStyleSheetComparer()
                 .AddTextComparer(WhitespaceOption.Normalize, ignoreCase: false)
                 .AddAttributeComparer()
                 .AddClassAttributeComparer()
                 .AddBooleanAttributeComparer(BooleanAttributeComparision.Strict)
-                .AddStyleAttributeComparer();
+                .AddStyleAttributeComparer()
+                .AddIgnoreChildrenElementSupport()
+                .AddIgnoreAttributesElementSupport()
+                ;
         }
     }
 }
diff --git a/src/AngleSharp.Diffing/Strategies/ElementStrategies/DiffingStrategyPipelineBuilderExtensions.cs b/src/AngleSharp.Diffing/Strategies/ElementStrategies/DiffingStrategyPipelineBuilderExtensions.cs
@@ -35,7 +35,7 @@ public static IDiffingStrategyCollection AddIgnoreElementSupport(this IDiffingSt
         }
 
         /// <summary>
-        /// Enables the ignore children element `diff:ignorechildren` attribute during diffing.
+        /// Enables the ignore children element `diff:ignoreChildren` attribute during diffing.
         /// </summary>
         /// <param name="builder"></param>
         /// <returns></returns>
@@ -44,5 +44,16 @@ public static IDiffingStrategyCollection AddIgnoreChildrenElementSupport(this ID
             builder.AddComparer(IgnoreChildrenElementComparer.Compare, StrategyType.Specialized);
             return builder;
         }
+
+        /// <summary>
+        /// Enables the ignore attributes element `diff:ignoreAttributes` attribute during diffing.
+        /// </summary>
+        /// <param name="builder"></param>
+        /// <returns></returns>
+        public static IDiffingStrategyCollection AddIgnoreAttributesElementSupport(this IDiffingStrategyCollection builder)
+        {
+            builder.AddComparer(IgnoreAttributesElementComparer.Compare, StrategyType.Specialized);
+            return builder;
+        }
     }
 }
diff --git a/src/AngleSharp.Diffing/Strategies/ElementStrategies/IgnoreAttributesElementComparer.cs b/src/AngleSharp.Diffing/Strategies/ElementStrategies/IgnoreAttributesElementComparer.cs
@@ -0,0 +1,34 @@
+using AngleSharp.Diffing.Core;
+using AngleSharp.Diffing.Extensions;
+using AngleSharp.Dom;
+
+namespace AngleSharp.Diffing.Strategies.ElementStrategies
+{
+    /// <summary>
+    /// Represents the ignore attributes element comparer.
+    /// </summary>
+    public static class IgnoreAttributesElementComparer
+    {
+        private const string DIFF_IGNORE_ATTRIBUTES_ATTRIBUTE = "diff:ignoreattributes";
+
+        /// <summary>
+        /// The ignore attributes element comparer.
+        /// </summary>
+        public static CompareResult Compare(in Comparison comparison, CompareResult currentDecision)
+        {
+            if (currentDecision == CompareResult.Skip)
+                return currentDecision;
+
+            return ControlHasTruthyIgnoreAttributesAttribute(comparison)
+                ? currentDecision | CompareResult.SkipAttributes
+                : currentDecision;
+        }
+
+        private static bool ControlHasTruthyIgnoreAttributesAttribute(in Comparison comparison)
+        {
+            return comparison.Control.Node is IElement element &&
+                    element.TryGetAttrValue(DIFF_IGNORE_ATTRIBUTES_ATTRIBUTE, out bool shouldIgnore) &&
+                    shouldIgnore;
+        }
+    }
+}
diff --git a/src/AngleSharp.Diffing/Strategies/ElementStrategies/IgnoreChildrenElementComparer.cs b/src/AngleSharp.Diffing/Strategies/ElementStrategies/IgnoreChildrenElementComparer.cs
@@ -19,12 +19,12 @@ public static CompareResult Compare(in Comparison comparison, CompareResult curr
             if (currentDecision == CompareResult.Skip)
                 return currentDecision;
 
-            return ControlHasTruthyIgnoreAttribute(comparison)
+            return ControlHasTruthyIgnoreChildrenAttribute(comparison)
                 ? currentDecision | CompareResult.SkipChildren
                 : currentDecision;
         }
 
-        private static bool ControlHasTruthyIgnoreAttribute(in Comparison comparison)
+        private static bool ControlHasTruthyIgnoreChildrenAttribute(in Comparison comparison)
         {
             return comparison.Control.Node is IElement element &&
                     element.TryGetAttrValue(DIFF_IGNORE_CHILDREN_ATTRIBUTE, out bool shouldIgnore) &&

Original file line number	Diff line number	Diff line change
`@@ -113,7 +113,8 @@ private IEnumerable<IDiff> CompareElement(in Comparison comparison)`
`113`	`113`
`114`	`114`	`if (compareRes != CompareResult.Skip)`
`115`	`115`	`{`
`116`		`- result.AddRange(CompareElementAttributes(comparison));`
	`116`	`+ if (!compareRes.HasFlag(CompareResult.SkipAttributes))`
	`117`	`+ result.AddRange(CompareElementAttributes(comparison));`
`117`	`118`	`if (!compareRes.HasFlag(CompareResult.SkipChildren))`
`118`	`119`	`result.AddRange(CompareChildNodes(comparison));`
`119`	`120`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,13 +19,15 @@ public static IDiffingStrategyCollection AddDefaultOptions(this IDiffingStrategy`
`19`	`19`	`.AddAttributeNameMatcher()`
`20`	`20`	`.AddElementComparer()`
`21`	`21`	`.AddIgnoreElementSupport()`
`22`		`- .AddIgnoreChildrenElementSupport()`
`23`	`22`	`.AddStyleSheetComparer()`
`24`	`23`	`.AddTextComparer(WhitespaceOption.Normalize, ignoreCase: false)`
`25`	`24`	`.AddAttributeComparer()`
`26`	`25`	`.AddClassAttributeComparer()`
`27`	`26`	`.AddBooleanAttributeComparer(BooleanAttributeComparision.Strict)`
`28`		`- .AddStyleAttributeComparer();`
	`27`	`+ .AddStyleAttributeComparer()`
	`28`	`+ .AddIgnoreChildrenElementSupport()`
	`29`	`+ .AddIgnoreAttributesElementSupport()`
	`30`	`+ ;`
`29`	`31`	`}`
`30`	`32`	`}`
`31`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ public static IDiffingStrategyCollection AddIgnoreElementSupport(this IDiffingSt`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`/// <summary>`
`38`		- /// Enables the ignore children element `diff:ignorechildren` attribute during diffing.
	`38`	+ /// Enables the ignore children element `diff:ignoreChildren` attribute during diffing.
`39`	`39`	`/// </summary>`
`40`	`40`	`/// <param name="builder"></param>`
`41`	`41`	`/// <returns></returns>`
`@@ -44,5 +44,16 @@ public static IDiffingStrategyCollection AddIgnoreChildrenElementSupport(this ID`
`44`	`44`	`builder.AddComparer(IgnoreChildrenElementComparer.Compare, StrategyType.Specialized);`
`45`	`45`	`return builder;`
`46`	`46`	`}`
	`47`	`+`
	`48`	`+ /// <summary>`
	`49`	+ /// Enables the ignore attributes element `diff:ignoreAttributes` attribute during diffing.
	`50`	`+ /// </summary>`
	`51`	`+ /// <param name="builder"></param>`
	`52`	`+ /// <returns></returns>`
	`53`	`+ public static IDiffingStrategyCollection AddIgnoreAttributesElementSupport(this IDiffingStrategyCollection builder)`
	`54`	`+ {`
	`55`	`+ builder.AddComparer(IgnoreAttributesElementComparer.Compare, StrategyType.Specialized);`
	`56`	`+ return builder;`
	`57`	`+ }`
`47`	`58`	`}`
`48`	`59`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,12 +19,12 @@ public static CompareResult Compare(in Comparison comparison, CompareResult curr`
`19`	`19`	`if (currentDecision == CompareResult.Skip)`
`20`	`20`	`return currentDecision;`
`21`	`21`
`22`		`- return ControlHasTruthyIgnoreAttribute(comparison)`
	`22`	`+ return ControlHasTruthyIgnoreChildrenAttribute(comparison)`
`23`	`23`	`? currentDecision \| CompareResult.SkipChildren`
`24`	`24`	`: currentDecision;`
`25`	`25`	`}`
`26`	`26`
`27`		`- private static bool ControlHasTruthyIgnoreAttribute(in Comparison comparison)`
	`27`	`+ private static bool ControlHasTruthyIgnoreChildrenAttribute(in Comparison comparison)`
`28`	`28`	`{`
`29`	`29`	`return comparison.Control.Node is IElement element &&`
`30`	`30`	`element.TryGetAttrValue(DIFF_IGNORE_CHILDREN_ATTRIBUTE, out bool shouldIgnore) &&`