Allow opacity percentage values, code cleanup

src/ExCSS.Tests/PropertyTests/OpacityPropertyTests.cs

@@ -0,0 +1,19 @@
+using Xunit;
+
+namespace ExCSS.Tests.PropertyTests;
+public class OpacityPropertyTests : CssConstructionFunctions
+{
+    [Fact]
+    public void OpacityPercentLegal()
+    {
+        var snippet = "opacity: 50%";
+        var property = ParseDeclaration(snippet);
+        Assert.Equal("opacity", property.Name);
+        Assert.False(property.IsImportant);
+        Assert.IsType<OpacityProperty>(property);
+        var concrete = (OpacityProperty)property;
+        Assert.False(concrete.IsInherited);
+        Assert.True(concrete.HasValue);
+        Assert.Equal("50%", concrete.Value);
+    }
+}

src/ExCSS/Conditions/AndCondition.cs

@@ -1,7 +1,7 @@
 using System.IO;
 using System.Linq;
 
-namespace ExCSS
+namespace ExCSS.Conditions
 {
     internal sealed class AndCondition : StylesheetNode, IConditionFunction
     {
@@ -20,13 +20,9 @@ public override void ToCss(TextWriter writer, IStyleFormatter formatter)
             foreach (var condition in conditions)
             {
                 if (first)
-                {
                     first = false;
-                }
                 else
-                {
                     writer.Write(" and ");
-                }
 
                 condition.ToCss(writer, formatter);
             }

src/ExCSS/Extensions/ValueExtensions.cs

@@ -42,7 +42,7 @@ public static string ToUri(this IEnumerable<Token> value)
         {
             var element = value.OnlyOrDefault();
 
-            if (element != null && element.Type == TokenType.Url) return element.Data;
+            if (element is { Type: TokenType.Url }) return element.Data;
 
             return null;
         }
@@ -86,17 +86,47 @@ public static Length ToLength(this FontSize fontSize)
         {
             var element = value.OnlyOrDefault();
 
-            if (element != null && element.Type == TokenType.Percentage)
-                return new Percent(((UnitToken) element).Value);
+            if (element is { Type: TokenType.Percentage })
+                return new Percent(((UnitToken)element).Value);
 
             return null;
         }
 
+        public static Percent? ToPercentOrFraction(this IEnumerable<Token> value)
+        {
+            var enumerable = value as Token[] ?? value.ToArray();
+            var percent = ToPercent(enumerable);
+
+            if (percent is not null)
+            {
+                return percent;
+            }
+
+            var element = enumerable.OnlyOrDefault();
+
+            if (element is not { Type: TokenType.Percentage })
+            {
+                return null;
+            }
+
+            var number = ((NumberToken)element).Value;
+
+            try
+            {
+                var percentage = number / 100;
+                return new Percent(percentage);
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
         public static string ToCssString(this IEnumerable<Token> value)
         {
             var element = value.OnlyOrDefault();
 
-            if (element != null && element.Type == TokenType.String) return element.Data;
+            if (element is { Type: TokenType.String }) return element.Data;
 
             return null;
         }

src/ExCSS/Model/Converters.cs

@@ -67,6 +67,9 @@ public static readonly IValueConverter
         public static readonly IValueConverter LengthOrPercentConverter =
             new StructValueConverter<Length>(ValueExtensions.ToDistance);
 
+        public static readonly IValueConverter PercentOrFractionConverter =
+            new StructValueConverter<Percent>(ValueExtensions.ToPercentOrFraction);
+
         public static readonly IValueConverter AngleNumberConverter =
             new StructValueConverter<Angle>(ValueExtensions.ToAngleNumber);
 
@@ -319,6 +322,7 @@ public static readonly IValueConverter
         public static readonly IValueConverter AutoLengthConverter = LengthConverter.OrAuto();
         public static readonly IValueConverter OptionalLengthOrPercentConverter = LengthOrPercentConverter.OrNone();
         public static readonly IValueConverter AutoLengthOrPercentConverter = LengthOrPercentConverter.OrAuto();
+        public static readonly IValueConverter OptionalPercentOrFractionConverter = PercentOrFractionConverter.OrDefault(1f);
 
         public static readonly IValueConverter FontSizeConverter =
             LengthOrPercentConverter.Or(Map.FontSizes.ToConverter());
@@ -460,11 +464,6 @@ public static IValueConverter Toggle(string on, string off)
             return Assign(on, true).Or(off, false);
         }
 
-        //public static IValueConverter WithFallback<T>(T fallbackValue) where T : struct, IFormattable
-        //{
-        //    return new StructValueConverter<T>(_ => fallbackValue);
-        //}
-
         #endregion
 
         #region Order / Unordered

src/ExCSS/Model/ParserExtensions.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using ExCSS.Conditions;
 
 namespace ExCSS
 {

src/ExCSS/Model/ValueBuilder.cs

@@ -44,7 +44,7 @@ public void Apply(Token token)
                     Add(token);
                     break;
                 case TokenType.Whitespace:
-                    if (_values.Count > 0 && IsSlash(_values[_values.Count - 1]) == false)
+                    if (_values.Count > 0 && IsSlash(_values[^1]) == false)
                         _buffer = token;
                     break;
                 case TokenType.Dimension:

src/ExCSS/Parser/SelectorConstructor.cs

@@ -652,34 +652,34 @@ public override ISelector Produce()
 
         private sealed class LangFunctionState : FunctionState
         {
-            private bool valid = true;
-            private string value ;
+            private bool _valid = true;
+            private string _value;
 
             protected override bool OnToken(Token token)
             {
                 if (token.Type == TokenType.Ident)
                 {
-                    value = token.Data;
+                    _value = token.Data;
                 }
                 else if (token.Type == TokenType.RoundBracketClose)
                 {
                     return true;
                 }
                 else if (token.Type != TokenType.Whitespace)
                 {
-                    valid = false;
+                    _valid = false;
                 }
 
                 return false;
             }
 
             public override ISelector Produce()
             {
-                if (!valid || value == null)
+                if (!_valid || _value == null)
                 {
                     return null;
                 }
-                var code = PseudoClassNames.Lang.StylesheetFunction(value);
+                var code = PseudoClassNames.Lang.StylesheetFunction(_value);
                 return PseudoClassSelector.Create(code);
 
             }
@@ -784,7 +784,7 @@ public ChildFunctionState(SelectorConstructor parent, bool withOptionalSelector
 
             public override ISelector Produce()
             {
-                var invalid = !_valid || _nested != null && !_nested.IsValid;
+                var invalid = !_valid || _nested is { IsValid: false };
                 var sel = _nested?.ToPool() ?? AllSelector.Create();
                 if (invalid)
                 {

src/ExCSS/Parser/StylesheetComposer.cs

@@ -583,7 +583,7 @@ public TextPosition FillDeclarations(StyleDeclaration style)
                             // times in the same style declaration.
                             // Example: "background-color:green !important; text-align:center; background-color:yellow;";
                             // In this example even though background-color yellow is defined last, the previous value
-                            // of green should be he one exposed given it is tagged as important.
+                            // of green should be the one exposed given it is tagged as important.
                             // ------------------------------------------------------------------------------------------
                             // Only set this property if one of the following conditions is true:
                             // a) It was not previously added or...

src/ExCSS/StyleProperties/Visibility/OpacityProperty.cs

@@ -2,10 +2,9 @@
 {
     internal sealed class OpacityProperty : Property
     {
-        private static readonly IValueConverter StyleConverter = Converters.NumberConverter.OrDefault(1f);
+        private static readonly IValueConverter StyleConverter = Converters.OptionalPercentOrFractionConverter;
 
-        internal OpacityProperty()
-            : base(PropertyNames.Opacity, PropertyFlags.Animatable)
+        internal OpacityProperty() : base(PropertyNames.Opacity, PropertyFlags.Animatable)
         {
         }