Node selectors done

Author: egil

Directory.Build.props

@@ -2,9 +2,10 @@
   <PropertyGroup>
     <LangVersion>8.0</LangVersion>
     <Nullable>enable</Nullable>
+    <WarningsAsErrors>CS8600;CS8602;CS8603;CS8625</WarningsAsErrors>
   </PropertyGroup>
   <PropertyGroup>
     <AngleSharpVersion>0.13.0</AngleSharpVersion>
-    <FxCopAnalyzersVersion>2.9.4</FxCopAnalyzersVersion>
+    <FxCopAnalyzersVersion>2.9.6</FxCopAnalyzersVersion>
   </PropertyGroup>
 </Project>

docs/Strategies.md

@@ -46,6 +46,8 @@ var diffs = DiffBuilder
     .Build();
 ``` 
 
+Read more about each of the strategies below, including some that are not part of the default set.
+
 ## Filter strategies
 These are the built-in filter strategies.
 
@@ -99,7 +101,7 @@ var diffs = DiffBuilder
 ```
 
 #### Forward-searching node matcher
-The forward-searching node-matcher strategy will only match control nodes with test nodes, if their `NodeName` match. It does this by taking one control node at the time, and searching from the previously matched test node until it finds a match. If it does not, it reports the control node as *missing*. After, any unmatched test nodes is reported as *unexpected*. 
+The forward-searching node-matcher strategy will only match control nodes with test nodes, if their `NodeName` match. It does this by taking one control node at the time, and searching after the previously matched test node until it finds a match. If it does not, continues with the next control node, and the unmatched control node is marked as *missing*. After, any unmatched test nodes is marked as *unexpected*. 
 
 The follow JavaScript-ish-code  illustrates how the algorithm works:
 
@@ -117,11 +119,11 @@ forwardSearchingMatcher(controlNodes, testNodes) {
                 lastMatchedTestNode = index
                 index = testNodes.length
             }
+            index++
         }
     }
     return matches
 }
-
 ```
 
 To choose this matcher, use the `WithSearchingNodeMatcher()` method on the `DiffBuilder` class, e.g.:

src/Core/AttributeComparison.cs

@@ -1,6 +1,5 @@
 using AngleSharp.Dom;
 using System;
-using System.Diagnostics.CodeAnalysis;
 
 namespace Egil.AngleSharp.Diffing.Core
 {

src/Core/Comparison.cs

@@ -1,13 +1,15 @@
 using System;
 using AngleSharp.Dom;
 using System.Diagnostics.CodeAnalysis;
+using System.Diagnostics;
 
 namespace Egil.AngleSharp.Diffing.Core
 {
     /// <summary>
     /// Represent a comparison between two nodes.
     /// </summary>
     /// <typeparam name="TNode"></typeparam>
+    [DebuggerDisplay("Control: {Control.Path} | Test: {Test.Path}")]
     public readonly struct Comparison : IEquatable<Comparison>
     {
         public ComparisonSource Control { get; }
@@ -23,7 +25,7 @@ public Comparison(in ComparisonSource control, in ComparisonSource test)
         public bool AreNodeTypesEqual() => Control.Node.NodeType == Test.Node.NodeType && Control.Node.NodeName == Test.Node.NodeName;
 
         public bool TryGetNodesAsType<TNode>([NotNullWhen(true)]out TNode? controlNode, [NotNullWhen(true)]out TNode? testNode) where TNode : class, INode
-        {
+        {            
             if (Control.Node is TNode ctrl && Test.Node is TNode test)
             {
                 controlNode = ctrl;

src/Core/ComparisonSource.cs

@@ -2,9 +2,11 @@
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using AngleSharp.Dom;
+using Egil.AngleSharp.Diffing.Extensions;
 
 namespace Egil.AngleSharp.Diffing.Core
 {
+    [SuppressMessage("Globalization", "CA1308:Normalize strings to uppercase", Justification = "Path should be in lower case")]
     [DebuggerDisplay("{Index} : {Path}")]
     public readonly struct ComparisonSource : IEquatable<ComparisonSource>, IComparisonSource
     {
@@ -18,7 +20,15 @@ namespace Egil.AngleSharp.Diffing.Core
 
         public ComparisonSourceType SourceType { get; }
 
-        [SuppressMessage("Globalization", "CA1308:Normalize strings to uppercase", Justification = "Path should be in lower case")]
+        public ComparisonSource(INode node, ComparisonSourceType sourceType)
+        {
+            Node = node;
+            Index = GetNodeIndex(node);
+            Path = CalculateNodePath(node, Index);
+            SourceType = sourceType;
+            _hashCode = (Node, Index, Path, SourceType).GetHashCode();
+        }
+
         public ComparisonSource(INode node, int index, string path, ComparisonSourceType sourceType)
         {
             if (node is null) throw new ArgumentNullException(nameof(node));
@@ -33,6 +43,30 @@ public ComparisonSource(INode node, int index, string path, ComparisonSourceType
             _hashCode = (Node, Index, Path, SourceType).GetHashCode();
         }
 
+        private static int GetNodeIndex(INode node)
+        {
+            if (node.TryGetNodeIndex(out var index))
+            {
+                return index;
+            }
+            else
+            {
+                throw new ArgumentException("When the node does not have a parent its index cannot be calculated.", nameof(node));
+            }
+        }
+
+        private static string CalculateNodePath(INode node, int index)
+        {
+            var path = $"{node.NodeName.ToLowerInvariant()}({index})";
+            var parent = node.Parent;
+            while (parent is { } && parent.TryGetNodeIndex(out var parentIndex))
+            {
+                path = $"{parent.NodeName.ToLowerInvariant()}({parentIndex}) > {path}";
+                parent = parent.Parent;
+            }
+            return path;
+        }
+
         #region Equals and HashCode
         public bool Equals(ComparisonSource other) => Node.Equals(other.Node) && Index == other.Index && Path.Equals(other.Path, StringComparison.Ordinal) && SourceType == other.SourceType;
         public override int GetHashCode() => _hashCode;

src/Core/SourceCollection.cs

@@ -33,9 +33,9 @@ public SourceCollection(ComparisonSourceType sourceType, IEnumerable<ComparisonS
             EnsureSourcesAreInCorrectOrder();
         }
 
-        public IEnumerable<ComparisonSource> GetUnmatched()
+        public IEnumerable<ComparisonSource> GetUnmatched(int startIndex = 0)
         {
-            for (int i = 0; i < _sources.Length; i++)
+            for (int i = startIndex; i < _sources.Length; i++)
             {
                 if (_status[_sources[i].Index] == SOURCE_UNMATCHED)
                 {

src/DiffingStrategyPipeline.cs

@@ -1,8 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using System.Collections.Generic;
 using Egil.AngleSharp.Diffing.Core;
 
 namespace Egil.AngleSharp.Diffing

src/Egil.AngleSharp.Diffing.csproj

@@ -2,8 +2,6 @@
 
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
-    <Nullable>enable</Nullable>
-    <WarningsAsErrors>CS8600;CS8602;CS8603;CS8625</WarningsAsErrors>
   </PropertyGroup>
 
   <ItemGroup>
@@ -14,7 +12,7 @@
 
   <ItemGroup>
     <PackageReference Include="AngleSharp" Version="$(AngleSharpVersion)" />
-    <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="2.9.5">
+    <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="$(FxCopAnalyzersVersion)">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>

src/Extensions/ElementExtensions.cs

@@ -13,6 +13,13 @@ public static bool TryGetAttrValue(this IElement element, string attributeName,
             static bool ParseBoolAttribute(string boolValue) => string.IsNullOrWhiteSpace(boolValue) || bool.Parse(boolValue);
         }
 
+        public static bool TryGetAttrValue(this IElement element, string attributeName, [NotNullWhen(true)]out string result)
+        {
+            return TryGetAttrValue(element, attributeName, GetStringAttrValue, out result);
+
+            static string GetStringAttrValue(string value) => value;
+        }
+
         public static bool TryGetAttrValue<T>(this IElement element, string attributeName, out T result) where T : System.Enum
         {
             return TryGetAttrValue(element, attributeName, ParseEnum, out result);
@@ -32,9 +39,9 @@ public static bool TryGetAttrValue<T>(this IElement element, string attributeNam
             }
             else
             {
-                #pragma warning disable CS8653 // A default expression introduces a null value for a type parameter.
+#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.
+#pragma warning restore CS8653 // A default expression introduces a null value for a type parameter.
                 return false;
             }
         }
@@ -63,5 +70,25 @@ public static T GetInlineOptionOrDefault<T>(this IElement startElement, string o
 
             return defaultValue;
         }
+
+        public static bool TryGetNodeIndex(this INode node, [NotNullWhen(true)]out int index)
+        {
+            index = -1;
+
+            if(node.ParentElement is null) return false;
+
+            var parentElement = node.ParentElement;
+
+            for (int i = 0; i < parentElement.ChildNodes.Length; i++)
+            {
+                if (parentElement.ChildNodes[i].Equals(node))
+                {
+                    index = i;
+                    return true;
+                }
+            }
+
+            return false;
+        }
     }
 }

src/Extensions/EnumExtensions.cs

@@ -1,8 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace Egil.AngleSharp.Diffing.Extensions
 {