Refactored 2nd time. Better diff output.

Author: egil

README.md

@@ -1,6 +1,26 @@
 Steps in finding differences:
 
-- NodeSelector/NodeFilter - filters away nodes that should not be part of the comparison
+```
+var diffs : []
+var currentPath : string
+var controlNodes : []
+var testNodes : []
+foreach (ctrlNode, index) in controlNodes
+    if(shouldSkip(ctrlNode)) continue;
+
+    ctrlSource = {ctrlNode, index, currentPath}
+    testNode = nodeMatcher(ctrlSource)
+
+
+    testSource = 
+
+
+nodeMatcher() ->
+``` 
+
+
+
+- NodeFilter - filters away nodes that should not be part of the comparison
   - Inline filter(ignorer)
 - NodeMatcher - matches a control-node with a test-node for comparison
 - Compare nodes by:

src/Comparison.cs

@@ -0,0 +1,24 @@
+using System;
+
+namespace Egil.AngleSharp.Diffing.Comparisons
+{
+    public readonly struct AttributeComparison : IEquatable<AttributeComparison>, IAttributeComparison
+    {
+        public IAttributeComparisonSource Control { get; }
+        public IAttributeComparisonSource Test { get; }
+
+        public AttributeComparison(IAttributeComparisonSource control, IAttributeComparisonSource test)
+        {
+            Control = control;
+            Test = test;
+        }
+
+        #region Equals and HashCode
+        public bool Equals(AttributeComparison other) => Control == other.Control && Test == other.Test;
+        public override bool Equals(object obj) => obj is AttributeComparison other && Equals(other);
+        public override int GetHashCode() => (Control, Test).GetHashCode();
+        public static bool operator ==(AttributeComparison left, AttributeComparison right) => left.Equals(right);
+        public static bool operator !=(AttributeComparison left, AttributeComparison right) => !(left == right);
+        #endregion
+    }
+}

src/ComparisonSource.cs

@@ -0,0 +1,26 @@
+using System;
+using AngleSharp.Dom;
+
+namespace Egil.AngleSharp.Diffing.Comparisons
+{
+    public readonly struct AttributeComparisonSource : IEquatable<AttributeComparisonSource>, IAttributeComparisonSource
+    {
+        public IAttr Attribute { get; }
+
+        public IComparisonSource<IElement> ElementSource { get; }
+
+        public AttributeComparisonSource(IAttr attribute, in IComparisonSource<IElement> elementSource)
+        {
+            Attribute = attribute;
+            ElementSource = elementSource;
+        }
+
+        #region Equals and HashCode
+        public bool Equals(AttributeComparisonSource other) => Attribute == other.Attribute && ElementSource == other.ElementSource;
+        public override int GetHashCode() => (Attribute, ElementSource).GetHashCode();
+        public override bool Equals(object obj) => obj is AttributeComparisonSource other && Equals(other);
+        public static bool operator ==(AttributeComparisonSource left, AttributeComparisonSource right) => left.Equals(right);
+        public static bool operator !=(AttributeComparisonSource left, AttributeComparisonSource right) => !(left == right);
+        #endregion
+    }
+}

src/Comparisons/AttributeComparison.cs

@@ -0,0 +1,32 @@
+using System;
+using AngleSharp.Dom;
+using Egil.AngleSharp.Diffing.Comparisons;
+
+namespace Egil.AngleSharp.Diffing
+{
+    /// <summary>
+    /// Represent a comparison between two nodes.
+    /// Create using <see cref="ComparisonFactory.Create(in IComparisonSource{INode}, in IComparisonSource{INode})"/>.
+    /// </summary>
+    /// <typeparam name="TNode"></typeparam>
+    public readonly struct Comparison<TNode> : IEquatable<Comparison<TNode>>, IComparison<TNode>
+        where TNode : INode
+    {
+        public IComparisonSource<TNode> Control { get; }
+        public IComparisonSource<TNode> Test { get; }
+
+        internal Comparison(in IComparisonSource<TNode> control, in IComparisonSource<TNode> test)
+        {
+            Control = control;
+            Test = test;
+        }
+
+        #region Equals and HashCode
+        public bool Equals(Comparison<TNode> other) => Control == other.Control && Test == other.Test;
+        public override bool Equals(object obj) => obj is Comparison<TNode> other && Equals(other);
+        public override int GetHashCode() => (Control, Test).GetHashCode();
+        public static bool operator ==(Comparison<TNode> left, Comparison<TNode> right) => left.Equals(right);
+        public static bool operator !=(Comparison<TNode> left, Comparison<TNode> right) => !(left == right);
+        #endregion
+    }
+}

src/Comparisons/AttributeComparisonSource.cs

@@ -0,0 +1,26 @@
+using System;
+using AngleSharp.Dom;
+using Egil.AngleSharp.Diffing.Comparisons;
+
+namespace Egil.AngleSharp.Diffing
+{
+    public static class ComparisonFactory
+    {
+        public static IComparison<INode> Create(in IComparisonSource<INode> control, in IComparisonSource<INode> test)
+        {
+            if (control is null) throw new ArgumentNullException(nameof(control));
+            if (test is null) throw new ArgumentNullException(nameof(test));
+
+            return control switch
+            {
+                IComparisonSource<IElement> elmCtrl when (test is IComparisonSource<IElement> elmTest)
+                    => new Comparison<IElement>(in elmCtrl, in elmTest),
+                IComparisonSource<IComment> cmtCtrl when (test is IComparisonSource<IComment> cmtTest)
+                    => new Comparison<IComment>(in cmtCtrl, in cmtTest),
+                IComparisonSource<IText> textCtrl when (test is IComparisonSource<IText> textTest)
+                    => new Comparison<IText>(in textCtrl, in textTest),
+                _ => new Comparison<INode>(in control, in test)
+            };
+        }
+    }
+}

src/Comparisons/Comparison.cs

@@ -0,0 +1,32 @@
+using System;
+using AngleSharp.Dom;
+
+namespace Egil.AngleSharp.Diffing.Comparisons
+{
+    public readonly struct ComparisonSource<TNode> : IEquatable<ComparisonSource<TNode>>, IComparisonSource<TNode> where TNode : INode
+    {
+        public TNode Node { get; }
+
+        public int Index { get; }
+
+        public string Path { get; }
+
+        public ComparisonSourceType SourceType { get; }
+
+        public ComparisonSource(TNode node, int index, string path, ComparisonSourceType sourceType)
+        {
+            Node = node;
+            Index = index;
+            Path = path;
+            SourceType = sourceType;
+        }
+
+        #region Equals and HashCode
+        public bool Equals(ComparisonSource<TNode> other) => Node.Equals(other.Node) && Index == other.Index && Path.Equals(other.Path, StringComparison.Ordinal) && SourceType == other.SourceType;
+        public override int GetHashCode() => (Node, Index, Path, SourceType).GetHashCode();
+        public override bool Equals(object obj) => obj is ComparisonSource<TNode> other && Equals(other);
+        public static bool operator ==(ComparisonSource<TNode> left, ComparisonSource<TNode> right) => left.Equals(right);
+        public static bool operator !=(ComparisonSource<TNode> left, ComparisonSource<TNode> right) => !(left == right);
+        #endregion
+    }
+}

src/Comparisons/ComparisonFactory.cs

@@ -0,0 +1,8 @@
+namespace Egil.AngleSharp.Diffing.Comparisons
+{
+    public interface IAttributeComparison
+    {
+        IAttributeComparisonSource Control { get; }
+        IAttributeComparisonSource Test { get; }
+    }
+}

src/Comparisons/ComparisonSource.cs

@@ -0,0 +1,10 @@
+using AngleSharp.Dom;
+
+namespace Egil.AngleSharp.Diffing.Comparisons
+{
+    public interface IAttributeComparisonSource
+    {
+        IAttr Attribute { get; }
+        IComparisonSource<IElement> ElementSource { get; }
+    }
+}