Tweaks for tests and classes

Author: egil

docs/Strategies.md

@@ -45,7 +45,6 @@ var diffs = DiffBuilder
     .WithClassAttributeComparer()
     .WithBooleanAttributeComparer(BooleanAttributeComparision.Strict)
     .WithStyleAttributeComparer()
-    .WithInlineAttributeIgnoreSupport()
     .Build();
 ``` 
 
@@ -405,14 +404,4 @@ To ignore a specific attribute during comparison, add the `:ignore` postfix to t
 <header>
     <h1 class:ignore="heading-1">Hello world</h1>
 </header>
-```
-
-Activate this strategy by calling the `WithInlineAttributeIgnoreSupport()` method on a `DiffBuilder` instance, e.g.:
-
-```csharp
-var diffs = DiffBuilder
-    .Compare(controlHtml)
-    .WithTest(testHtml)
-    .WithInlineAttributeIgnoreSupport()
-    .Build();
 ```

src/Core/AttributeComparison.cs

@@ -14,12 +14,12 @@ public AttributeComparison(in AttributeComparisonSource control, in AttributeCom
             Control = control;
             Test = test;
         }
-        
-        public (IElement ControlElement, IElement TestElement) GetAttributeElements() 
+
+        public (IElement ControlElement, IElement TestElement) GetAttributeElements()
             => ((IElement)Control.ElementSource.Node, (IElement)Test.ElementSource.Node);
 
         #region Equals and HashCode
-        public bool Equals(AttributeComparison other) => Control == other.Control && Test == other.Test;
+        public bool Equals(AttributeComparison other) => Control.Equals(other.Control) && Test.Equals(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);

src/Core/AttributeComparisonSource.cs

@@ -29,7 +29,7 @@ public AttributeComparisonSource(string attributeName, in ComparisonSource eleme
         }
 
         #region Equals and HashCode
-        public bool Equals(AttributeComparisonSource other) => Attribute == other.Attribute && ElementSource == other.ElementSource && Path.Equals(other.Path, StringComparison.Ordinal);
+        public bool Equals(AttributeComparisonSource other) => Attribute == other.Attribute && ElementSource.Equals(other.ElementSource) && Path.Equals(other.Path, StringComparison.Ordinal);
         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);

src/Core/Diffs/DiffBase.cs

@@ -4,8 +4,7 @@
 namespace Egil.AngleSharp.Diffing.Core
 {
     [DebuggerDisplay("Diff={Target} {Result}")]
-    public abstract class DiffBase<T> : IDiff, IEquatable<DiffBase<T>>
-        where T : struct
+    public abstract class DiffBase<T> : IDiff where T : struct
     {
         public T Control { get; }
 
@@ -22,18 +21,5 @@ protected DiffBase(in T control, in T test, DiffTarget target)
             Result = DiffResult.Different;
             Target = target;
         }
-
-        public bool Equals(DiffBase<T> other) => !(other is null) && Control.Equals(other.Control) && Test.Equals(other.Test) && Result == other.Result && Target == other.Target;
-        public override bool Equals(object obj) => obj is DiffBase<T> other && Equals(other);
-        public override int GetHashCode() => (Control, Test, Result, Target).GetHashCode();
-        public static bool operator ==(DiffBase<T> left, DiffBase<T> right)
-        {
-            if (left is null && right is null)
-                return true;
-            if (!(left is null))
-                return left.Equals(right);
-            return false;
-        }
-        public static bool operator !=(DiffBase<T> left, DiffBase<T> right) => !(left == right);
     }
 }

src/Core/Diffs/MissingDiffBase.cs

@@ -2,7 +2,7 @@
 
 namespace Egil.AngleSharp.Diffing.Core
 {
-    public abstract class MissingDiffBase<T> : IDiff, IEquatable<MissingDiffBase<T>> where T : struct
+    public abstract class MissingDiffBase<T> : IDiff where T : struct
     {
         public T Control { get; }
 
@@ -16,19 +16,5 @@ protected MissingDiffBase(in T control, DiffTarget target)
             Result = DiffResult.Missing;
             Target = target;
         }
-
-        public bool Equals(MissingDiffBase<T> other) => !(other is null) && Control.Equals(other.Control) && Result == other.Result && Target == other.Target;
-        public override bool Equals(object obj) => obj is MissingDiffBase<T> other && Equals(other);
-        public override int GetHashCode() => (Control, Result, Target).GetHashCode();
-        public static bool operator ==(MissingDiffBase<T> left, MissingDiffBase<T> right)
-        {
-            if (left is null && right is null)
-                return true;
-            if (!(left is null))
-                return left.Equals(right);
-            return false;
-        }
-
-        public static bool operator !=(MissingDiffBase<T> left, MissingDiffBase<T> right) => !(left == right);
     }
 }

src/Core/Diffs/UnexpectedDiffBase.cs

@@ -4,7 +4,7 @@
 namespace Egil.AngleSharp.Diffing.Core
 {
     [DebuggerDisplay("Diff={Target} {Result}]")]
-    public abstract class UnexpectedDiffBase<T> : IDiff, IEquatable<UnexpectedDiffBase<T>> where T : struct
+    public abstract class UnexpectedDiffBase<T> : IDiff where T : struct
     {
         public T Test { get; }
 
@@ -18,19 +18,5 @@ protected UnexpectedDiffBase(in T test, DiffTarget target)
             Result = DiffResult.Unexpected;
             Target = target;
         }
-
-        public bool Equals(UnexpectedDiffBase<T> other) => !(other is null) && Test.Equals(other.Test) && Result == other.Result && Target == other.Target;
-        public override bool Equals(object obj) => obj is UnexpectedDiffBase<T> other && Equals(other);
-        public override int GetHashCode() => (Test, Result, Target).GetHashCode();
-        public static bool operator ==(UnexpectedDiffBase<T> left, UnexpectedDiffBase<T> right)
-        {
-            if (left is null && right is null)
-                return true;
-            if (!(left is null))
-                return left.Equals(right);
-            return false;
-        }
-
-        public static bool operator !=(UnexpectedDiffBase<T> left, UnexpectedDiffBase<T> right) => !(left == right);
     }
 }

src/Strategies/AttributeStrategies/DiffingStrategyPipelineExtensions.cs

@@ -33,6 +33,7 @@ public static DiffingStrategyPipeline WithAttributeComparer(this DiffingStrategy
         {
             pipeline.AddMatcher(PostfixedAttributeMatcher.Match, isSpecializedMatcher: true);
             pipeline.AddComparer(AttributeComparer.Compare, isSpecializedComparer: false);
+            pipeline.AddComparer(IgnoreAttributeComparer.Compare, isSpecializedComparer: true);
             return pipeline;
         }
 
@@ -54,16 +55,6 @@ public static DiffingStrategyPipeline WithBooleanAttributeComparer(this DiffingS
             return pipeline;
         }
 
-        /// <summary>
-        /// Enables ignoring attributes using the :ignore postfix for attributes during diffing.
-        /// </summary>
-        public static DiffingStrategyPipeline WithInlineAttributeIgnoreSupport(this DiffingStrategyPipeline pipeline)
-        {
-            pipeline.AddMatcher(IgnoreAttributeMatcher.Match, isSpecializedMatcher: true);
-            pipeline.AddComparer(IgnoreAttributeComparer.Compare, isSpecializedComparer: true);
-            return pipeline;
-        }
-
         /// <summary>
         /// Enables the special style attributes comparer during diffing.
         /// </summary>

src/Strategies/AttributeStrategies/IgnoreAttributeMatcher.cs

@@ -31,8 +31,7 @@ public static DiffingStrategyPipeline WithDefaultOptions(this DiffingStrategyPip
                 .WithAttributeComparer()
                 .WithClassAttributeComparer()
                 .WithBooleanAttributeComparer(BooleanAttributeComparision.Strict)
-                .WithStyleAttributeComparer()
-                .WithInlineAttributeIgnoreSupport();
+                .WithStyleAttributeComparer();
             ;
         }
     }