Refactored value model names

Author: FlorianRappl

CHANGELOG.md

@@ -4,6 +4,7 @@ Released on tbd.
 
 - Updated to use AngleSharp 1.0 (#150)
 - Updated media parsing to media L4 spec (#133)
+- Updated naming of CSS values (e.g., `Color` to `CssColorValue`)
 - Fixed issue when updating shorthands with invalid values (#129)
 - Fixed issue with appended EOF character in `CssText` (#123)
 - Fixed missing semicolon in `@page` rule (#135)
@@ -15,6 +16,7 @@ Released on tbd.
 - Fixed `GetInnerText` multi-line / text node behavior (#155) @Seyden
 - Fixed computation of relative (`em`) values to absolute (`px`) for `Length` (#136)
 - Added further compactification of CSS tuples (#89, #93)
+- Added new value types `CssPercentageValue`, `CssNumberValue`, and `CssIntegerValue`
 - Added support for CSS nesting in style rules (#148)
 - Added resolution of CSS variable names (#62)
 - Added support for 8-digit hex color codes (#132)

CONTRIBUTORS.md

@@ -17,6 +17,7 @@ AngleSharp.Css contains code written by (in order of first pull request / commit
 * [Fraaankes](https://github.com/Fraaankes)
 * [Eric Mutta](https://github.com/ericmutta)
 * [Seyden](https://github.com/Seyden)
+* [Dave Dunkin](https://github.com/ddunkin)
 
 Without these awesome people AngleSharp.Css could not exist. Thanks to everyone for your contributions! :beers:
 

src/AngleSharp.Css.Tests/Values/Gradient.cs

@@ -204,11 +204,11 @@ public void LengthToVminCorrectValue()
         public void AngleParseCorrectDegValue()
         {
             var s = "1.35e2deg";
-            var v = default(Angle);
-            var r = Angle.TryParse(s, out v);
+            var v = default(CssAngleValue);
+            var r = CssAngleValue.TryParse(s, out v);
             Assert.IsTrue(r);
             Assert.AreEqual(135f, v.Value);
-            Assert.AreEqual(Angle.Unit.Deg, v.Type);
+            Assert.AreEqual(CssAngleValue.Unit.Deg, v.Type);
         }
 
         [Test]
@@ -248,8 +248,8 @@ public void TimeParseCorrectSecondsValue()
         public void AngleParseIncorrectValue()
         {
             var s = "123.deg";
-            var v = default(Angle);
-            var r = Angle.TryParse(s, out v);
+            var v = default(CssAngleValue);
+            var r = CssAngleValue.TryParse(s, out v);
             Assert.IsFalse(r);
         }
     }

src/AngleSharp.Css.Tests/Values/UnitConversion.cs

@@ -26,16 +26,16 @@ static class Map
         /// <summary>
         /// Contains the string-Angle mapping for linear-gradients.s
         /// </summary>
-        public static readonly Dictionary<String, Angle> GradientAngles = new(StringComparer.OrdinalIgnoreCase)
-        {
-            { CssKeywords.Left, new Angle(270.0, Angle.Unit.Deg) },
-            { CssKeywords.Top, new Angle(0.0, Angle.Unit.Deg) },
-            { CssKeywords.Right, new Angle(90.0, Angle.Unit.Deg) },
-            { CssKeywords.Bottom, new Angle(180.0, Angle.Unit.Deg) },
-            { CssKeywords.LeftTop, new Angle(315.0, Angle.Unit.Deg) },
-            { CssKeywords.LeftBottom, new Angle(225.0, Angle.Unit.Deg) },
-            { CssKeywords.RightTop, new Angle(45.0, Angle.Unit.Deg) },
-            { CssKeywords.RightBottom, new Angle(135.0, Angle.Unit.Deg) },
+        public static readonly Dictionary<String, CssAngleValue> GradientAngles = new(StringComparer.OrdinalIgnoreCase)
+        {
+            { CssKeywords.Left, new CssAngleValue(270.0, CssAngleValue.Unit.Deg) },
+            { CssKeywords.Top, new CssAngleValue(0.0, CssAngleValue.Unit.Deg) },
+            { CssKeywords.Right, new CssAngleValue(90.0, CssAngleValue.Unit.Deg) },
+            { CssKeywords.Bottom, new CssAngleValue(180.0, CssAngleValue.Unit.Deg) },
+            { CssKeywords.LeftTop, new CssAngleValue(315.0, CssAngleValue.Unit.Deg) },
+            { CssKeywords.LeftBottom, new CssAngleValue(225.0, CssAngleValue.Unit.Deg) },
+            { CssKeywords.RightTop, new CssAngleValue(45.0, CssAngleValue.Unit.Deg) },
+            { CssKeywords.RightBottom, new CssAngleValue(135.0, CssAngleValue.Unit.Deg) },
         };
 
         /// <summary>

src/AngleSharp.Css/Constants/Map.cs

@@ -108,9 +108,9 @@ public ICssValue Convert(StringSource source)
                 return null;
             }
 
-            private sealed class ContentValue : ICssValue
+            private sealed class ContentValue : ICssValue, IEquatable<ContentValue>
             {
-                private ICssValue[] _modes;
+                private readonly ICssValue[] _modes;
 
                 public ContentValue(ICssValue[] modes)
                 {
@@ -124,6 +124,30 @@ public ICssValue Compute(ICssComputeContext context)
                     var modes = _modes.Select(mode => mode.Compute(context)).ToArray();
                     return new ContentValue(modes);
                 }
+                public Boolean Equals(ContentValue other)
+                {
+                    var l = _modes.Length;
+
+                    if (l == other._modes.Length)
+                    {
+                        for (var i = 0; i < l; i++)
+                        {
+                            var a = _modes[i];
+                            var b = other._modes[i];
+
+                            if (!a.Equals(b))
+                            {
+                                return false;
+                            }
+                        }
+
+                        return true;
+                    }
+
+                    return false;
+                }
+
+                Boolean IEquatable<ICssValue>.Equals(ICssValue other) => other is ContentValue value && Equals(value);
             }
 
             private abstract class ContentMode : ICssValue
@@ -134,10 +158,9 @@ private abstract class ContentMode : ICssValue
 
                 public abstract String GetCssText();
 
-                ICssValue ICssValue.Compute(ICssComputeContext context)
-                {
-                    return this;
-                }
+                ICssValue ICssValue.Compute(ICssComputeContext context) => this;
+
+                public virtual Boolean Equals(ICssValue other) => Object.ReferenceEquals(this, other);
             }
 
             /// <summary>
@@ -209,6 +232,16 @@ public TextContentMode(String text)
                 public override String GetCssText() => _text.CssString();
 
                 public override String Stringify(IElement element) => _text;
+
+                public override Boolean Equals(ICssValue other)
+                {
+                    if (other is TextContentMode o)
+                    {
+                        return _text.Equals(o._text);
+                    }
+
+                    return false;
+                }
             }
 
             /// <summary>
@@ -228,6 +261,16 @@ public CounterContentMode(CssCounterDefinitionValue counter)
                 public override String GetCssText() => _counter.CssText;
 
                 public override String Stringify(IElement element) => String.Empty;
+
+                public override Boolean Equals(ICssValue other)
+                {
+                    if (other is CounterContentMode o)
+                    {
+                        return _counter.Equals(o._counter);
+                    }
+
+                    return false;
+                }
             }
 
             /// <summary>
@@ -246,6 +289,16 @@ public AttributeContentMode(String attribute)
                 public override String GetCssText() => FunctionNames.Attr.CssFunction(_attribute);
 
                 public override String Stringify(IElement element) => element.GetAttribute(_attribute) ?? String.Empty;
+
+                public override Boolean Equals(ICssValue other)
+                {
+                    if (other is AttributeContentMode o)
+                    {
+                        return _attribute.Equals(o._attribute);
+                    }
+
+                    return false;
+                }
             }
 
             /// <summary>
@@ -265,6 +318,16 @@ public UrlContentMode(CssUrlValue url)
                 public override String GetCssText() => _url.CssText;
 
                 public override String Stringify(IElement element) => String.Empty;
+
+                public override Boolean Equals(ICssValue other)
+                {
+                    if (other is UrlContentMode o)
+                    {
+                        return _url.Equals(o._url);
+                    }
+
+                    return false;
+                }
             }
         }
     }

src/AngleSharp.Css/Declarations/ContentDeclaration.cs

@@ -21,20 +21,19 @@ sealed class CursorValueConverter : IValueConverter
         {
             public ICssValue Convert(StringSource source)
             {
-                var cursor = default(ICssValue);
                 var definitions = new List<ICssValue>();
 
                 while (!source.IsDone)
                 {
                     var imageSource = source.ParseImageSource();
-                    var c = source.SkipSpacesAndComments();
+                    source.SkipSpacesAndComments();
 
                     if (imageSource != null)
                     {
                         var x = source.ParseNumber();
-                        c = source.SkipSpacesAndComments();
+                        source.SkipSpacesAndComments();
                         var y = source.ParseNumber();
-                        c = source.SkipSpacesAndComments();
+                        var c = source.SkipSpacesAndComments();
 
                         if (x.HasValue != y.HasValue || c != Symbols.Comma)
                             break;
@@ -44,16 +43,14 @@ public ICssValue Convert(StringSource source)
 
                         if (x.HasValue)
                         {
-                            var xp = new CssLengthValue(x.Value, CssLengthValue.Unit.None);
-                            var yp = new CssLengthValue(y.Value, CssLengthValue.Unit.None);
-                            position = new CssPoint2D(xp, yp);
+                            position = new CssPoint2D(x, y);
                         }
 
                         definitions.Add(new CssCustomCursorValue(imageSource, position));
                     }
                     else
                     {
-                        cursor = source.ParseConstant(Map.SystemCursors);
+                        var cursor = source.ParseConstant(Map.SystemCursors);
 
                         if (cursor != null)
                         {

src/AngleSharp.Css/Declarations/CursorDeclaration.cs

@@ -1,12 +1,12 @@
 namespace AngleSharp.Css.Dom
 {
-    using System;
     using AngleSharp.Css.Values;
+    using System;
 
     /// <summary>
     /// Represents a value of a CSS property.
     /// </summary>
-    public interface ICssValue
+    public interface ICssValue : IEquatable<ICssValue>
     {
         /// <summary>
         /// The text representation of the value.