DiffPipelineStrategy

Author: egil

README.md

@@ -15,7 +15,7 @@ var diffs = DiffBuilder
 
 #### Built-in filters: 
 - **`RemoveCommentNodeFilter`**: remove all comment nodes.
-- whitespace only text nodes
+- ** whitespace only text nodes
 
 Matchers:
 - searching matcher, that will match nodes of the same type, and, optionally, element with the same element name.

src/Core/HtmlDifferenceEngine.cs

@@ -58,12 +58,12 @@ private IEnumerable<IDiff> CompareNodeLists(DiffContext context, SourceCollectio
 
         private void ApplyNodeFilter(SourceCollection sources)
         {
-            sources.Remove(_filterStrategy.NodeFilter);
+            sources.Remove(_filterStrategy.Filter);
         }
 
         private IEnumerable<Comparison> MatchNodes(DiffContext context, SourceCollection controls, SourceCollection tests)
         {
-            foreach (var comparison in _matcherStrategy.MatchNodes(context, controls, tests))
+            foreach (var comparison in _matcherStrategy.Match(context, controls, tests))
             {
                 MarkSelectedSourcesAsMatched(comparison);
                 yield return comparison;
@@ -146,12 +146,12 @@ private IEnumerable<IDiff> CompareElementAttributes(DiffContext context, in Comp
 
         private void ApplyFilterAttributes(SourceMap controlAttrs)
         {
-            controlAttrs.Remove(_filterStrategy.AttributeFilter);
+            controlAttrs.Remove(_filterStrategy.Filter);
         }
 
         private IEnumerable<AttributeComparison> MatchAttributes(DiffContext context, SourceMap controls, SourceMap tests)
         {
-            foreach (var comparison in _matcherStrategy.MatchAttributes(context, controls, tests))
+            foreach (var comparison in _matcherStrategy.Match(context, controls, tests))
             {
                 MarkSelectedSourcesAsMatched(comparison);
                 yield return comparison;

src/Core/IFilterStrategy.cs

@@ -11,13 +11,13 @@ public interface IFilterStrategy
         /// </summary>
         /// <param name="comparisonSource">A comparison source for the node</param>
         /// <returns>true if the node should be part of the comparison, false if the node should be filtered out.</returns>
-        bool NodeFilter(in ComparisonSource comparisonSource);
+        bool Filter(in ComparisonSource comparisonSource);
 
         /// <summary>
         /// Decides whether an attribute should be part of the comparison.
         /// </summary>
         /// <param name="comparisonSource">A comparison source for the attribute</param>
         /// <returns>true if the attribute should be part of the comparison, false if the attribute should be filtered out.</returns>
-        bool AttributeFilter(in AttributeComparisonSource attributeComparisonSource);
+        bool Filter(in AttributeComparisonSource attributeComparisonSource);
     }
 }

src/Core/IMatcherStrategy.cs

@@ -14,14 +14,14 @@ public interface IMatcherStrategy
         /// depending on whether they are control or test nodes.
         /// </summary>
         /// <returns></returns>
-        IEnumerable<Comparison> MatchNodes(DiffContext context, SourceCollection controlSources, SourceCollection testSources);
+        IEnumerable<Comparison> Match(DiffContext context, SourceCollection controlSources, SourceCollection testSources);
 
         /// <summary>
         /// Matches up the control attributes with test attributes in the two input lists. The matched control and test attributes will be compared to each other.
         /// Any unmatched control or test attributes will be reported as either <see cref="DiffResult.Missing"/> or <see cref="DiffResult.Unexpected"/>,
         /// depending on whether they are control or test attributes.
         /// </summary>
         /// <returns></returns>
-        IEnumerable<AttributeComparison> MatchAttributes(DiffContext context, SourceMap controlAttrSources, SourceMap testAttrSources);
+        IEnumerable<AttributeComparison> Match(DiffContext context, SourceMap controlAttrSources, SourceMap testAttrSources);
     }
 }

src/DiffingStrategyPipeline.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Egil.AngleSharp.Diffing.Core;
+
+namespace Egil.AngleSharp.Diffing
+{
+    public delegate bool FilterStrategy<TSource>(in TSource source, bool currentDecision);
+    public delegate IEnumerable<TComparison> MatchStrategy<in TSources, out TComparison>(DiffContext context, TSources controlSources, TSources testSources);
+    public delegate CompareResult CompareStrategy<TComparison>(in TComparison comparison, CompareResult currentDecision);
+
+    public class DiffingStrategyPipeline : IFilterStrategy, IMatcherStrategy, ICompareStrategy
+    {
+        private readonly List<FilterStrategy<ComparisonSource>> _nodeFilters = new List<FilterStrategy<ComparisonSource>>();
+        private readonly List<FilterStrategy<AttributeComparisonSource>> _attrsFilters = new List<FilterStrategy<AttributeComparisonSource>>();
+        private readonly List<MatchStrategy<SourceCollection, Comparison>> _nodeMatchers = new List<MatchStrategy<SourceCollection, Comparison>>();
+        private readonly List<MatchStrategy<SourceMap, AttributeComparison>> _attrsMatchers = new List<MatchStrategy<SourceMap, AttributeComparison>>();
+        private readonly List<CompareStrategy<Comparison>> _nodeComparers = new List<CompareStrategy<Comparison>>();
+        private readonly List<CompareStrategy<AttributeComparison>> _attrComparers = new List<CompareStrategy<AttributeComparison>>();
+
+        public bool Filter(in ComparisonSource comparisonSource) => Filter(comparisonSource, _nodeFilters);
+        public bool Filter(in AttributeComparisonSource attributeComparisonSource) => Filter(attributeComparisonSource, _attrsFilters);
+
+        public IEnumerable<Comparison> Match(DiffContext context, SourceCollection controlSources, SourceCollection testSources)
+            => Match(context, controlSources, testSources, _nodeMatchers);
+
+        public IEnumerable<AttributeComparison> Match(DiffContext context, SourceMap controlAttrSources, SourceMap testAttrSources)
+            => Match(context, controlAttrSources, testAttrSources, _attrsMatchers);
+
+        public CompareResult Compare(in Comparison comparison) 
+            => Compare(comparison, _nodeComparers, CompareResult.DifferentAndBreak);
+
+        public CompareResult Compare(in AttributeComparison comparison)
+            => Compare(comparison, _attrComparers, CompareResult.Different);
+
+        public void AddFilter(FilterStrategy<ComparisonSource> filterStrategy) => _nodeFilters.Add(filterStrategy);
+        public void AddFilter(FilterStrategy<AttributeComparisonSource> filterStrategy) => _attrsFilters.Add(filterStrategy);
+
+        public void AddMatcher(MatchStrategy<SourceCollection, Comparison> matchStrategy) => _nodeMatchers.Add(matchStrategy);
+        public void AddMatcher(MatchStrategy<SourceMap, AttributeComparison> matchStrategy) => _attrsMatchers.Add(matchStrategy);
+
+        public void AddComparer(CompareStrategy<Comparison> compareStrategy) => _nodeComparers.Add(compareStrategy);
+        public void AddComparer(CompareStrategy<AttributeComparison> compareStrategy) => _attrComparers.Add(compareStrategy);
+
+        private bool Filter<T>(in T source, List<FilterStrategy<T>> filterStrategies)
+        {
+            var result = true;
+            for (int i = 0; i < filterStrategies.Count; i++)
+            {
+                result = filterStrategies[i](source, result);
+            }
+            return result;
+        }
+
+        private IEnumerable<TComparison> Match<TSources, TComparison>(DiffContext context, TSources controlSources, TSources testSources, List<MatchStrategy<TSources, TComparison>> matchStrategies)
+        {
+            foreach (var matcher in matchStrategies)
+            {
+                foreach (var comparison in matcher(context, controlSources, testSources))
+                {
+                    yield return comparison;
+                }
+            }
+        }
+
+        private CompareResult Compare<TComparison>(in TComparison comparison, List<CompareStrategy<TComparison>> compareStrategies, CompareResult initialResult)
+        {
+            var result = initialResult;
+            foreach (var comparer in compareStrategies)
+            {
+                result = comparer(comparison, result);
+            }
+            return result;
+        }
+    }
+}

tests/Core/DiffingTestBase.cs

@@ -71,12 +71,12 @@ public MockMatcherStrategy(
                 _attrMatcher = attrMatcher;
             }
 
-            public IEnumerable<Comparison> MatchNodes(
+            public IEnumerable<Comparison> Match(
                 DiffContext context,
                 SourceCollection controlNodes,
                 SourceCollection testNodes) => _nodeMatcher!(context, controlNodes, testNodes);
 
-            public IEnumerable<AttributeComparison> MatchAttributes(
+            public IEnumerable<AttributeComparison> Match(
                 DiffContext context,
                 SourceMap controlAttributes,
                 SourceMap testAttributes) => _attrMatcher!(context, controlAttributes, testAttributes);
@@ -93,10 +93,10 @@ public MockFilterStrategy(Func<ComparisonSource, bool>? nodeFilter = null, Func<
                 _attrFilter = attrFilter;
             }
 
-            public bool AttributeFilter(in AttributeComparisonSource attributeComparisonSource)
+            public bool Filter(in AttributeComparisonSource attributeComparisonSource)
                 => _attrFilter!(attributeComparisonSource);
 
-            public bool NodeFilter(in ComparisonSource comparisonSource)
+            public bool Filter(in ComparisonSource comparisonSource)
                 => _nodeFilter!(comparisonSource);
         }
 

tests/DiffingStrategyPipelineTest.cs

@@ -0,0 +1,114 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using AngleSharp.Dom;
+using Egil.AngleSharp.Diffing.Core;
+using Shouldly;
+using Xunit;
+
+namespace Egil.AngleSharp.Diffing
+{
+    public class DiffingStrategyPipelineTest : DiffingTestBase
+    {
+        [Fact(DisplayName = "Wen zero filter strategies have been added, true is returned")]
+        public void Test1()
+        {
+            var sut = new DiffingStrategyPipeline();
+
+            sut.Filter(new ComparisonSource()).ShouldBeTrue();
+            sut.Filter(new AttributeComparisonSource()).ShouldBeTrue();
+        }
+
+        [Theory(DisplayName = "When one or more filter strategy is added, the last decides the outcome")]
+        [InlineData(true)]
+        [InlineData(false)]
+        public void Test5(bool expected)
+        {
+            var sut = new DiffingStrategyPipeline();
+
+            sut.AddFilter((in ComparisonSource s, bool currentDecision) => !expected);
+            sut.AddFilter((in ComparisonSource s, bool currentDecision) => expected);
+            sut.AddFilter((in AttributeComparisonSource s, bool currentDecision) => !expected);
+            sut.AddFilter((in AttributeComparisonSource s, bool currentDecision) => expected);
+
+            sut.Filter(new ComparisonSource()).ShouldBe(expected);
+            sut.Filter(new AttributeComparisonSource()).ShouldBe(expected);
+        }
+
+        #pragma warning disable CS8625 // Cannot convert null literal to non-nullable reference type.
+        #pragma warning disable CS8600 // Converting null literal or possible null value to non-nullable type.
+        [Fact(DisplayName = "When no matcher strategy have been added, none comparisons are returned")]
+        public void Test2()
+        {
+            var sut = new DiffingStrategyPipeline();
+
+            sut.Match(null, null, (SourceCollection)null).ShouldBeEmpty();
+            sut.Match(null, null, (SourceMap)null).ShouldBeEmpty();
+        }
+        #pragma warning restore CS8600 // Converting null literal or possible null value to non-nullable type.
+        #pragma warning restore CS8625 // Cannot convert null literal to non-nullable reference type.
+
+        [Fact(DisplayName = "Node Matchers are allowed to match in the order they are added in")]
+        public void Test6()
+        {
+            var sources = ToComparisonSourceList("<p></p><span></span>").ToList();
+            var context = new DiffContext((IElement)sources[0].Node, (IElement)sources[0].Node);
+            var sourceColllection = new SourceCollection(ComparisonSourceType.Control, sources);
+            var sut = new DiffingStrategyPipeline();
+            sut.AddMatcher((ctx, s, t) => new[] { new Comparison(s[0], t[0]) });
+            sut.AddMatcher((ctx, s, t) => new[] { new Comparison(s[1], t[1]) });
+
+            var result = sut.Match(context, sourceColllection, sourceColllection).ToList();
+
+            result[0].Control.ShouldBe(sources[0]);
+            result[1].Control.ShouldBe(sources[1]);
+        }
+
+        [Fact(DisplayName = "Attributes Matchers are allowed to match in the order they are added in")]
+        public void Test7()
+        {
+            var source = ToComparisonSource(@"<p foo=""bar"" baz=""bum""></p>");
+            var context = new DiffContext((IElement)source.Node, (IElement)source.Node);
+            var sourceMap = new SourceMap(source);
+            var sut = new DiffingStrategyPipeline();
+            sut.AddMatcher((ctx, s, t) => new[] { new AttributeComparison(s["foo"], t["foo"]) });
+            sut.AddMatcher((ctx, s, t) => new[] { new AttributeComparison(s["baz"], t["baz"]) });
+
+            var result = sut.Match(context, sourceMap, sourceMap).ToList();
+
+            result[0].Control.ShouldBe(sourceMap["foo"]);
+            result[1].Control.ShouldBe(sourceMap["baz"]);
+        }
+
+        [Fact(DisplayName = "When no compare strategy have been added, DifferentAndBreak is returned for node comparison and Different for attributes")]
+        public void Test3()
+        {
+            var sut = new DiffingStrategyPipeline();
+
+            sut.Compare(new Comparison()).ShouldBe(CompareResult.DifferentAndBreak);
+            sut.Compare(new AttributeComparison()).ShouldBe(CompareResult.Different);
+        }
+
+        [Theory(DisplayName = "When multiple comparers are added, the last decides the outcome")]
+        [InlineData(CompareResult.Different, CompareResult.Same)]
+        [InlineData(CompareResult.Same, CompareResult.Different)]
+        [InlineData(CompareResult.Same, CompareResult.SameAndBreak)]
+        [InlineData(CompareResult.Different, CompareResult.DifferentAndBreak)]
+
+        public void Test8(CompareResult first, CompareResult final)
+        {
+            var sut = new DiffingStrategyPipeline();
+
+            sut.AddComparer((in Comparison c, CompareResult current) => first);
+            sut.AddComparer((in Comparison c, CompareResult current) => final);
+            sut.AddComparer((in AttributeComparison c, CompareResult current) => first);
+            sut.AddComparer((in AttributeComparison c, CompareResult current) => final);
+
+            sut.Compare(new Comparison()).ShouldBe(final);
+            sut.Compare(new AttributeComparison()).ShouldBe(final);
+        }
+
+    }
+}