Diff Engine done.

Author: egil

src/CompareResult.cs

@@ -0,0 +1,8 @@
+namespace Egil.AngleSharp.Diffing
+{
+    public enum CompareResult
+    {
+        Same,
+        Different
+    }
+}

src/Comparisons/AttributeComparisonSource.cs

@@ -1,5 +1,6 @@
 using System;
 using AngleSharp.Dom;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Egil.AngleSharp.Diffing.Comparisons
 {
@@ -9,14 +10,24 @@ namespace Egil.AngleSharp.Diffing.Comparisons
 
         public IComparisonSource<IElement> ElementSource { get; }
 
+        public string Path { get; }
+
+        public ComparisonSourceType SourceType { get; }
+
+        [SuppressMessage("Globalization", "CA1308:Normalize strings to uppercase", Justification = "Path should be in lower case")]
         public AttributeComparisonSource(IAttr attribute, in IComparisonSource<IElement> elementSource)
         {
+            if (attribute is null) throw new ArgumentNullException(nameof(attribute));
+            if (elementSource is null) throw new ArgumentNullException(nameof(elementSource));
+
             Attribute = attribute;
             ElementSource = elementSource;
+            SourceType = elementSource.SourceType;
+            Path = $"{elementSource.Path}[{attribute.Name.ToLowerInvariant()}]";
         }
 
         #region Equals and HashCode
-        public bool Equals(AttributeComparisonSource other) => Attribute == other.Attribute && ElementSource == other.ElementSource;
+        public bool Equals(AttributeComparisonSource other) => Attribute == other.Attribute && ElementSource == 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/Comparisons/Comparison.cs

@@ -1,8 +1,7 @@
 using System;
 using AngleSharp.Dom;
-using Egil.AngleSharp.Diffing.Comparisons;
 
-namespace Egil.AngleSharp.Diffing
+namespace Egil.AngleSharp.Diffing.Comparisons
 {
     /// <summary>
     /// Represent a comparison between two nodes.

src/Comparisons/ComparisonFactory.cs

@@ -1,5 +1,4 @@
-using System;
-using AngleSharp.Dom;
+using AngleSharp.Dom;
 using Egil.AngleSharp.Diffing.Comparisons;
 
 namespace Egil.AngleSharp.Diffing
@@ -8,8 +7,8 @@ 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));
+            if (control is null) throw new System.ArgumentNullException(nameof(control));
+            if (test is null) throw new System.ArgumentNullException(nameof(test));
 
             return control switch
             {

src/Comparisons/ComparisonSource.cs

@@ -1,5 +1,6 @@
 using System;
 using AngleSharp.Dom;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Egil.AngleSharp.Diffing.Comparisons
 {
@@ -13,11 +14,15 @@ namespace Egil.AngleSharp.Diffing.Comparisons
 
         public ComparisonSourceType SourceType { get; }
 
+        [SuppressMessage("Globalization", "CA1308:Normalize strings to uppercase", Justification = "Path should be in lower case")]
         public ComparisonSource(TNode node, int index, string path, ComparisonSourceType sourceType)
         {
             Node = node;
             Index = index;
-            Path = path;
+            Path = string.IsNullOrEmpty(path) 
+                ? $"{Node.NodeName.ToLowerInvariant()}({Index})" 
+                : $"{path} > {Node.NodeName.ToLowerInvariant()}({Index})";
+
             SourceType = sourceType;
         }
 

src/Comparisons/IAttributeComparison.cs

@@ -1,8 +1,19 @@
 namespace Egil.AngleSharp.Diffing.Comparisons
 {
+    /// <summary>
+    /// Represents a comparison between two attributes, 
+    /// that have been matched up for comparison.
+    /// </summary>
     public interface IAttributeComparison
     {
+        /// <summary>
+        /// Gets the control <see cref="IAttributeComparisonSource"/>, that represents the expected attribute.
+        /// </summary>
         IAttributeComparisonSource Control { get; }
+
+        /// <summary>
+        /// Gets the test <see cref="IAttributeComparisonSource"/>, which should be compared against <see cref="Control"/>.
+        /// </summary>
         IAttributeComparisonSource Test { get; }
     }
 }

src/Comparisons/IAttributeComparisonSource.cs

@@ -2,9 +2,29 @@
 
 namespace Egil.AngleSharp.Diffing.Comparisons
 {
+    /// <summary>
+    /// A input source for an attribute comparison. 
+    /// </summary>
     public interface IAttributeComparisonSource
     {
+        /// <summary>
+        /// Gets the attribute which should take part in a comparison.
+        /// </summary>
         IAttr Attribute { get; }
+
+        /// <summary>
+        /// Gets the source of the element which the attribute belongs to.
+        /// </summary>
         IComparisonSource<IElement> ElementSource { get; }
+
+        /// <summary>
+        /// Gets an CSS-selector like representation of the path to the attribute in the DOM-tree.
+        /// </summary>
+        string Path { get; }
+
+        /// <summary>
+        /// Gets the source type, i.e. if this is a <see cref="ComparisonSourceType.Control"/> or <see cref="ComparisonSourceType.Test"/> source.
+        /// </summary>
+        ComparisonSourceType SourceType { get; }
     }
 }

src/Comparisons/IComparison.cs

@@ -6,10 +6,20 @@
 
 namespace Egil.AngleSharp.Diffing.Comparisons
 {
+    /// <summary>
+    /// Represents a single comparison between a control node and a test node.
+    /// </summary>
+    /// <typeparam name="TNode"></typeparam>
     public interface IComparison<out TNode> where TNode : INode
     {
+        /// <summary>
+        /// Gets the Control node source, which should be used as the baseline to compare the <see cref="Test"/> node source with.
+        /// </summary>
         IComparisonSource<TNode> Control { get; }
 
+        /// <summary>
+        /// Gets the Test node source, which should be compare to the <see cref="Control"/> node source.
+        /// </summary>
         IComparisonSource<TNode> Test { get; }
     }
 }

src/Comparisons/IComparisonSource.cs

@@ -2,11 +2,30 @@
 
 namespace Egil.AngleSharp.Diffing.Comparisons
 {
+    /// <summary>
+    /// A input source for an node comparison. 
+    /// </summary>
+    /// <typeparam name="TNode">The type of the node</typeparam>
     public interface IComparisonSource<out TNode> where TNode : INode
     {
+        /// <summary>
+        /// Gets the node which should take part in a comparison.
+        /// </summary>
         TNode Node { get; }
+
+        /// <summary>
+        /// Gets the index of the node in the DOM-tree, relative to its siblings.
+        /// </summary>
         int Index { get; }
+
+        /// <summary>
+        /// Gets an CSS-selector like representation of the path to the node in the DOM-tree.
+        /// </summary>
         string Path { get; }
+
+        /// <summary>
+        /// Gets the source type, i.e. if this is a <see cref="ComparisonSourceType.Control"/> or <see cref="ComparisonSourceType.Test"/> source.
+        /// </summary>
         ComparisonSourceType SourceType { get; }
     }
 }

src/Diffs/AttrDiff.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Diagnostics;
+using Egil.AngleSharp.Diffing.Comparisons;
+
+namespace Egil.AngleSharp.Diffing
+{
+    [DebuggerDisplay("Diff={Target} {Result} Control={Control.Node.NodeName}[{Control.Index}] Test={Test.Node.NodeName}[{Test.Index}]")]
+    public readonly struct AttrDiff : IDiff, IEquatable<AttrDiff>
+    {
+        public IAttributeComparisonSource Control { get; }
+
+        public IAttributeComparisonSource Test { get; }
+
+        public DiffResult Result { get; }
+
+        public DiffTarget Target { get; }
+
+        internal AttrDiff(in IAttributeComparison comparison)
+        {
+            if (comparison is null) throw new ArgumentNullException(nameof(comparison));
+            Control = comparison.Control;
+            Test = comparison.Test;
+            Result = DiffResult.Different;
+            Target = DiffTarget.Attribute;
+        }
+
+        public bool Equals(AttrDiff other) => Control.Equals(other.Control) && Test.Equals(other.Test) && Result == other.Result && Target == other.Target;
+        public override bool Equals(object obj) => obj is AttrDiff other && Equals(other);
+        public override int GetHashCode() => (Control, Test, Result, Target).GetHashCode();
+        public static bool operator ==(AttrDiff left, AttrDiff right) => left.Equals(right);
+        public static bool operator !=(AttrDiff left, AttrDiff right) => !(left == right);
+    }
+}