Small refactoring

Author: egil

README.md

@@ -58,14 +58,17 @@ var diffs = DiffBuilder
 
 _**NOTE**: Currently, the ignore comment strategy does NOT remove comments from CSS or JavaScript embedded in `<style>` or `<script>` tags._
 
-### Whitespace handling
+### Text (text nodes) strategies
+The built-in text strategies offer a bunch of ways to control how text (text nodes) is handled during the diffing process.
+
+#### Whitespace handling
 Whitespace can be a source of false-positives when comparing two HTML fragments. Thus, the whitespace handling strategy offer different ways to deal with it during a comparison.
 
-- `Preserve`: Does not change or filter out any whitespace in control and test HTML. Default, same as not specifying any options.
+- `Preserve` (default): Does not change or filter out any whitespace in text nodes the control and test HTML.
 - `RemoveWhitespaceNodes`: Using this option filters out all text nodes that only consist of whitespace characters.
-- `Normalize`: Using this option will _trim_ all text nodes and replace two or more whitespace characters with a single space character.
+- `Normalize`: Using this option will _trim_ all text nodes and replace two or more whitespace characters with a single space character. This option implicitly includes the `RemoveWhitespaceNodes` option.
 
-These options can be set either _globally_ for the entire comparison, or on a _specific subtrees in the comparison_. 
+These options can be set either _globally_ for the entire comparison, or inline on a _specific subtrees in the comparison_. 
 
 To set a global default, call the method `Whitespace(WhitespaceOption)` on a `DiffBuilder` instance, e.g.:
 
@@ -77,15 +80,15 @@ var diffs = DiffBuilder
     .Build();
 ```
 
-To configure/override whitespace rules on a specific subtree in the comparison, use the `diff:whitespace="WhitespaceOption"` on a control node, and it and all nodes below it will use that whitespace option, unless it is overridden on a child node. In the example below, all whitespace inside the `<h1>` element is preserved:
+To configure/override whitespace rules on a specific subtree in the comparison, use the `diff:whitespace="WhitespaceOption"` inline on a control element, and it and all text nodes below it will use that whitespace option, unless it is overridden on a child element. In the example below, all whitespace inside the `<h1>` element is preserved:
 
 ```html
 <header>
-    <h1 diff:whitespace="Preserve">Hello   <em> woooorld</em></h1>
+    <h1 diff:whitespace="preserve">Hello   <em> woooorld</em></h1>
 </header>
 ```
 
-**Special case for `<pre>`-tags:** The content of `<pre />` tags will always be treated as the `Preserve` option, even if whitespace strategy is globally set to `RemoveWhitespaceNodes` or `Normalize`. To override this, add a local `diff:whitespace" attribute to the tag, e.g.:
+**Special case for `<pre>` elements:** The content of `<pre>` elements will always be treated as the `Preserve` option, even if whitespace option is globally set to `RemoveWhitespaceNodes` or `Normalize`. To override this, add a inline `diff:whitespace` attribute to the `<pre>`-tag, e.g.:
 
 ```html
 <pre diff:whitespace="RemoveWhitespaceNodes">...</pre>
@@ -95,6 +98,38 @@ To configure/override whitespace rules on a specific subtree in the comparison,
 
 **Special case for `<script>`-tags:**  It is on the issues list to deal with whitespace properly inside `<script>`-tags.
 
+#### Perform case-_insensitve_ text comparison
+To compare the text in two text nodes to eachother using a case-insensitive comparison, call the `IgnoreCase()` method on a `DiffBuilder` instance, e.g.:
+
+```csharp
+var diffs = DiffBuilder
+    .Compare(controlHtml)
+    .WithTest(testHtml)
+    .IgnoreCase()
+    .Build();
+```
+
+To configure/override ignore case rules on a specific subtree in the comparison, use the `diff:ignoreCase="true|false"` inline on a control element, and it and all text nodes below it will use that ignore case setting, unless it is overridden on a child element. In the example below, ignore case is set active for all text inside the `<h1>` element:
+
+```html
+<header>
+    <h1 diff:ignoreCase="true">Hello   <em> woooorld</em></h1>
+</header>
+```
+
+Note, as with all HTML5 boolean attributes, the `="true"` or `="false"` parts are optional.
+
+#### Use regular expression when comparing text
+By using the inline attribute `diff:regex` on the element containing the text node being compared, the comparer will consider the control text to be a regular expression, and will use that to test whether the test text node is as expected. This can be combined with the inline `diff:ignoreCase` attribute, to make the regular expression case-insensitive. E.g.:
+
+```html
+<header>
+    <h1 diff:regex diff:ignoreCase>Hello World \d{4}</h1>
+</header>
+```
+
+The above  control text would use case-insensitive regular expression to match against a test text string (e.g. "HELLO WORLD 2020").
+
 ### Ignore attribute
 If the `diff:ignore="true"` attribute is used on a control element  (`="true"` implicit/optional), all their attributes and child nodes are skipped/ignored during comparison, including those of the test element, the control element is matched with.
 

src/Extensions/ElementExtensions.cs

@@ -7,30 +7,36 @@ namespace Egil.AngleSharp.Diffing.Extensions
     public static class ElementExtensions
     {
         public static bool TryGetAttrValue(this IElement element, string attributeName, out bool result)
-            => TryGetAttrValue(element, attributeName, x => string.IsNullOrWhiteSpace(x) || bool.Parse(x), out result);
+        {
+            return TryGetAttrValue(element, attributeName, ParseBoolAttribute, out result);
+
+            static bool ParseBoolAttribute(string boolValue) => string.IsNullOrWhiteSpace(boolValue) || bool.Parse(boolValue);
+        }
 
         public static bool TryGetAttrValue<T>(this IElement element, string attributeName, out T result) where T : System.Enum
         {
             return TryGetAttrValue(element, attributeName, ParseEnum, out result);
 
-            static T ParseEnum(string enumValue)
-            {
-                return (T)Enum.Parse(typeof(T), enumValue, true);
-            }
+            static T ParseEnum(string enumValue) => (T)Enum.Parse(typeof(T), enumValue, true);
         }
 
         public static bool TryGetAttrValue<T>(this IElement element, string attributeName, Func<string, T> resultFunc, [NotNullWhen(true)] out T result)
         {
             if (element is null) throw new ArgumentNullException(nameof(element));
             if (resultFunc is null) throw new ArgumentNullException(nameof(resultFunc));
 
-            result = default;
             if (element.Attributes[attributeName] is IAttr optAttr)
             {
                 result = resultFunc(optAttr.Value);
                 return true;
             }
-            return false;
+            else
+            {
+                #pragma warning disable CS8653 // A default expression introduces a null value for a type parameter.
+                result = default;
+                #pragma warning restore CS8653 // A default expression introduces a null value for a type parameter.
+                return false;
+            }
         }
 
         public static TEnum GetInlineOptionOrDefault<TEnum>(this IElement startElement, string optionName, TEnum defaultValue)
@@ -41,6 +47,9 @@ public static bool GetInlineOptionOrDefault(this IElement startElement, string o
 
         public static T GetInlineOptionOrDefault<T>(this IElement startElement, string optionName, Func<string, T> resultFunc, T defaultValue)
         {
+            if (startElement is null) throw new ArgumentNullException(nameof(startElement));
+            if (resultFunc is null) throw new ArgumentNullException(nameof(resultFunc));
+
             var element = startElement;
 
             while (element is { })

src/Strategies/TextNodeStrategies/TextNodeFilter.cs

@@ -24,10 +24,10 @@ public TextNodeFilter(WhitespaceOption option)
         public FilterDecision Filter(in ComparisonSource source, FilterDecision currentDecision)
         {
             if (currentDecision.IsExclude()) return currentDecision;
-            return source.Node is IText textNode ? Filter(source, textNode) : currentDecision;
+            return source.Node is IText textNode ? Filter(textNode) : currentDecision;
         }
 
-        private FilterDecision Filter(in ComparisonSource source, IText textNode)
+        private FilterDecision Filter(IText textNode)
         {
             var option = GetWhitespaceOption(textNode);
             return option != WhitespaceOption.Preserve && string.IsNullOrWhiteSpace(textNode.Data)

tests/DiffingStrategyPipelineTest.cs

@@ -15,7 +15,8 @@ public class DiffingStrategyPipelineTest : DiffingTestBase
         private FilterDecision NegateDecision(FilterDecision decision) => decision switch
         {
             FilterDecision.Keep => FilterDecision.Exclude,
-            FilterDecision.Exclude => FilterDecision.Keep
+            FilterDecision.Exclude => FilterDecision.Keep,
+            _ => throw new InvalidOperationException()
         };
 
         [Fact(DisplayName = "Wen zero filter strategies have been added, true is returned")]
@@ -116,5 +117,6 @@ public void Test8(CompareResult first, CompareResult final)
             sut.Compare(new AttributeComparison()).ShouldBe(final);
         }
 
+        // if compare returns andStop, dont call any more comparers?
     }
 }

tests/Strategies/TextNodeStrategies/TextNodeFilterTest.cs

@@ -60,7 +60,7 @@ public void Test5()
         }
 
         [Fact(DisplayName = "If parent node is <pre> element with a diff:whitespace, the option is take from the attribute")]
-        public void Test5_1()
+        public void Test51()
         {
             var sut = new TextNodeFilter(WhitespaceOption.Normalize);
             var pre = ToComparisonSource("<pre diff:whitespace=\"RemoveWhitespaceNodes\"> \n\t </pre>");