Updated diff stuff

Author: egil

README.md

@@ -1,19 +1,28 @@
-# AngleSharp.Diffing 
+# AngleSharp Diffing - A diff/compare library for AngleSharp
 This library makes it possible to compare a AngleSharp _control_ `INodeList` and a _test_ `INodeList` and get a list of `IDiff` differences between them.
 
 The _control_ nodes represents the expected, i.e. how the nodes are expected to look, and the _test_ nodes represents the other nodes that should be compared to the _control_ nodes.
 
 ## Usage
 
-Filters:
-- remove comments
+```csharp
+var diffs = DiffBuilder
+    .Compare(controlHtml)
+    .WithTest(testHtml)
+    .Build();
+
+```
+
+#### Built-in filters: 
+- **`RemoveCommentNodeFilter`**: remove all comment nodes.
 - whitespace only text nodes
 
 Matchers:
 - searching matcher, that will match nodes of the same type, and, optionally, element with the same element name.
 - css selector matcher nodes and for attributes
 
 Comparers:
+- **`DiffIgnoreAttributeComparer`**: allows you to specify an special attribute `diff:ignore="true"` (`="true"` optional) on control elements to ignore them, their attributes, and child nodes, during comparison. E.g. `<p diff:ignore>...</p>`. 
 - ignore consecutive whitespace comparer inside textnodes (not in strings in script and style tags).
 - regex comparer
 - ignore case comparer (attr/text)

docs/HtmlDifferenceEngineFlow.svg

@@ -2,7 +2,21 @@
 {
     public enum CompareResult
     {
+        /// <summary>
+        /// Indicates the two compared nodes or attributes are the same.
+        /// </summary>
         Same,
-        Different
+        /// <summary>
+        /// Indicates the two compared nodes or attributes are the same AND no further comparison should happen on any child nodes or attributes.
+        /// </summary>
+        SameAndBreak,
+        /// <summary>
+        /// Indicates the two compared nodes or attributes are the different.
+        /// </summary>
+        Different,
+        /// <summary>
+        /// Indicates the two compared nodes or attributes are the different AND no further comparison should happen on any child nodes or attributes.
+        /// </summary>
+        DifferentAndBreak
     }
 }

docs/HtmlDifferenceEngineFlow.vsdx

@@ -0,0 +1,6 @@
+using Egil.AngleSharp.Diffing.Comparisons;
+
+namespace Egil.AngleSharp.Diffing.Comparers.Chainable
+{
+    public delegate CompareResult ChainableAttributeComparerStrategy(in IAttributeComparison comparison, CompareResult currentDecision);
+}

src/CompareResult.cs

@@ -0,0 +1,8 @@
+using AngleSharp.Dom;
+using Egil.AngleSharp.Diffing.Comparisons;
+
+namespace Egil.AngleSharp.Diffing.Comparers.Chainable
+{
+    public delegate CompareResult ChainableNodeComparerStrategy<TNode>(in IComparison<TNode> comparison, CompareResult currentDecision)
+        where TNode : INode;
+}

src/Comparers/Chainable/ChainableAttributeComparerStrategy.cs

@@ -0,0 +1,135 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using AngleSharp.Dom;
+using Egil.AngleSharp.Diffing.Comparisons;
+
+namespace Egil.AngleSharp.Diffing.Comparers.Chainable
+{
+    public class ChainedCompareStrategy : ICompareStrategy
+    {
+        private readonly List<IChainableNodeCompareStrategy<IElement>> _elementComparers = new List<IChainableNodeCompareStrategy<IElement>>();
+        private readonly List<IChainableNodeCompareStrategy<IComment>> _commentComparers = new List<IChainableNodeCompareStrategy<IComment>>();
+        private readonly List<IChainableNodeCompareStrategy<IText>> _textComparers = new List<IChainableNodeCompareStrategy<IText>>();
+        private readonly List<IChainableNodeCompareStrategy<INode>> _nodeComparers = new List<IChainableNodeCompareStrategy<INode>>();
+        private readonly List<IChainableAttributeCompareStrategy> _attrComparers = new List<IChainableAttributeCompareStrategy>();
+
+        public CompareResult Compare<TNode>(in IComparison<TNode> nodeComparison) where TNode : INode
+        {
+            return nodeComparison switch
+            {
+                IComparison<IElement> comparison => ApplyNodeComparers(in comparison, _elementComparers),
+                IComparison<IComment> comparison => ApplyNodeComparers(in comparison, _commentComparers),
+                IComparison<IText> comparison => ApplyNodeComparers(in comparison, _textComparers),
+                IComparison<INode> comparison => ApplyNodeComparers(in comparison, _nodeComparers),
+                _ => throw new InvalidOperationException("Unknown comparison type")
+            };
+        }
+
+        private CompareResult ApplyNodeComparers<TNode>(in IComparison<TNode> comparison, List<IChainableNodeCompareStrategy<TNode>> comparers) where TNode : INode
+        {
+            var result = CompareResult.Same;
+
+            foreach (var comparer in comparers)
+            {
+                result = comparer.Compare(comparison, result);
+            }
+
+            return result;
+        }
+
+        public CompareResult Compare(in IAttributeComparison comparison)
+        {
+            var result = CompareResult.Same;
+
+            foreach (var comparer in _attrComparers)
+            {
+                result = comparer.Compare(comparison, result);
+            }
+
+            return result;
+        }
+
+        public void AddComparer<TNode>(ChainableNodeComparerStrategy<TNode> comparer)
+            where TNode : INode
+        {
+            switch (comparer)
+            {
+                case ChainableNodeComparerStrategy<IElement> filter:
+                    AddComparer(new NodeComparerDelegateWrapper<IElement>(filter));
+                    break;
+                case ChainableNodeComparerStrategy<IComment> filter:
+                    AddComparer(new NodeComparerDelegateWrapper<IComment>(filter));
+                    break;
+                case ChainableNodeComparerStrategy<IText> filer:
+                    AddComparer(new NodeComparerDelegateWrapper<IText>(filer));
+                    break;
+                case ChainableNodeComparerStrategy<INode> filer:
+                    AddComparer(new NodeComparerDelegateWrapper<INode>(filer));
+                    break;
+            }
+        }
+
+        public void AddComparer(ChainableAttributeComparerStrategy comparer) => AddComparer(new AttrComparerDelegateWrapper(comparer));
+
+        public void AddComparer(IChainableNodeCompareStrategy<IElement> compareStrategy)
+        {
+            _elementComparers.Add(compareStrategy);
+        }
+
+        public void AddComparer(IChainableNodeCompareStrategy<IComment> compareStrategy)
+        {
+            _commentComparers.Add(compareStrategy);
+        }
+
+        public void AddComparer(IChainableNodeCompareStrategy<IText> compareStrategy)
+        {
+            _textComparers.Add(compareStrategy);
+        }
+
+        public void AddComparer(IChainableNodeCompareStrategy<INode> compareStrategy)
+        {
+            _elementComparers.Add(compareStrategy);
+            _commentComparers.Add(compareStrategy);
+            _textComparers.Add(compareStrategy);
+            _nodeComparers.Add(compareStrategy);
+        }
+
+        public void AddComparer(IChainableAttributeCompareStrategy compareStrategy)
+        {
+            _attrComparers.Add(compareStrategy);
+        }
+    }
+
+    class NodeComparerDelegateWrapper<TNode> : IChainableNodeCompareStrategy<TNode> where TNode : INode
+    {
+        private readonly ChainableNodeComparerStrategy<TNode> _strategy;
+
+        public NodeComparerDelegateWrapper(ChainableNodeComparerStrategy<TNode> strategy)
+        {
+            _strategy = strategy;
+        }
+
+        public CompareResult Compare(IComparison<TNode> comparison, CompareResult currentDecision)
+        {
+            return _strategy(comparison, currentDecision);
+        }
+    }
+
+    class AttrComparerDelegateWrapper : IChainableAttributeCompareStrategy
+    {
+        private readonly ChainableAttributeComparerStrategy _strategy;
+
+        public AttrComparerDelegateWrapper(ChainableAttributeComparerStrategy strategy)
+        {
+            _strategy = strategy;
+        }
+
+        public CompareResult Compare(IAttributeComparison comparison, CompareResult currentDecision)
+        {
+            return _strategy(comparison, currentDecision);
+        }
+    }
+}

src/Comparers/Chainable/ChainableNodeComparerStrategy.cs

@@ -0,0 +1,9 @@
+using Egil.AngleSharp.Diffing.Comparisons;
+
+namespace Egil.AngleSharp.Diffing.Comparers.Chainable
+{
+    public interface IChainableAttributeCompareStrategy
+    {
+        CompareResult Compare(IAttributeComparison comparison, CompareResult currentDecision);
+    }
+}

src/Comparers/Chainable/ChainedCompareStrategy.cs

@@ -0,0 +1,10 @@
+using AngleSharp.Dom;
+using Egil.AngleSharp.Diffing.Comparisons;
+
+namespace Egil.AngleSharp.Diffing.Comparers.Chainable
+{
+    public interface IChainableNodeCompareStrategy<in TNode> where TNode : INode
+    {
+        CompareResult Compare(IComparison<TNode> comparison, CompareResult currentDecision);
+    }
+}

src/Comparers/Chainable/IChainableAttributeCompareStrategy.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using AngleSharp.Dom;
+using Egil.AngleSharp.Diffing.Comparisons;
+using Egil.AngleSharp.Diffing.Comparers.Chainable;
+
+namespace Egil.AngleSharp.Diffing.Comparers
+{
+    public class DiffIgnoreAttributeCompareStrategy : IChainableNodeCompareStrategy<IElement>
+    {
+        public CompareResult Compare(IComparison<IElement> comparison, CompareResult currentDecision)
+        {
+            if (comparison is null) throw new ArgumentNullException(nameof(comparison));
+
+            var ignoreAttr = comparison.Control.Node.Attributes["diff:ignore"];
+
+            if (ignoreAttr is { } && ignoreAttr.IsEmptyOrEquals("TRUE"))
+                return CompareResult.SameAndBreak;
+            else 
+                return currentDecision;
+        }
+    }
+}