tsai
/
Avalonia
mirror of https://github.com/AvaloniaUI/Avalonia.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Add support for parsing BoxShadows with color functions (#20321) 

* Add support for parsing BoxShadows with colors expressions with parentheses

* Added BoxShadowsTests

* BoxShadow parsing should also respect parentheses

* Add StringSplitter

* Fix test

* Apply suggestions from code review

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* StringSplitter should not accept same bracket pairs

* Returns empty array only when input is null

* Add StringSplitterTests

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
pull/20345/head
Ge 2 months ago
committed by GitHub
parent
a7f09f4315
commit
62597de97c
No known key found for this signature in database GPG Key ID: B5690EEEBB952194
5 changed files with 377 additions and 4 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 7
      src/Avalonia.Base/Media/BoxShadow.cs
  2. 10
      src/Avalonia.Base/Media/BoxShadows.cs
  3. 114
      src/Avalonia.Base/Utilities/StringSplitter.cs
  4. 75
      tests/Avalonia.Base.UnitTests/Media/BoxShadowsTests.cs
  5. 175
      tests/Avalonia.Base.UnitTests/Utilities/StringSplitterTests.cs

7
src/Avalonia.Base/Media/BoxShadow.cs
View File

@ -12,6 +12,8 @@ namespace Avalonia.Media
public struct BoxShadow
{
private readonly static char[] s_Separator = new char[] { ' ', '\t' };
private const char OpeningParenthesis = '(';
private const char ClosingParenthesis = ')';
/// <summary>
/// Gets or sets the horizontal offset (distance) of the shadow.
@ -208,7 +210,10 @@ namespace Avalonia.Media
throw new FormatException();
}
var p = s.Split(s_Separator, StringSplitOptions.RemoveEmptyEntries);
var p = StringSplitter.SplitRespectingBrackets(
s, s_Separator,
OpeningParenthesis, ClosingParenthesis,
StringSplitOptions.RemoveEmptyEntries);
if (p.Length == 1 && p[0] == "none")
{
return default;

10
src/Avalonia.Base/Media/BoxShadows.cs
View File

@ -9,7 +9,9 @@ namespace Avalonia.Media
/// </summary>
public struct BoxShadows
{
private static readonly char[] s_Separators = new[] { ',' };
private const char Separator = ',';
private const char OpeningParenthesis = '(';
private const char ClosingParenthesis = ')';
private readonly BoxShadow _first;
private readonly BoxShadow[]? _list;
@ -120,7 +122,9 @@ namespace Avalonia.Media
/// <returns>A new <see cref="BoxShadows"/> collection.</returns>
public static BoxShadows Parse(string s)
{
var sp = s.Split(s_Separators, StringSplitOptions.RemoveEmptyEntries);
var sp = StringSplitter.SplitRespectingBrackets(
s, Separator, OpeningParenthesis, ClosingParenthesis,
StringSplitOptions.RemoveEmptyEntries);
if (sp.Length == 0
|| (sp.Length == 1 &&
(string.IsNullOrWhiteSpace(sp[0])
@ -236,7 +240,7 @@ namespace Avalonia.Media
/// <returns>
/// <c>true</c> if the two <see cref="BoxShadows"/> collections are equal; otherwise, <c>false</c>.
/// </returns>
public static bool operator ==(BoxShadows left, BoxShadows right) =>
public static bool operator ==(BoxShadows left, BoxShadows right) =>
left.Equals(right);
/// <summary>

114
src/Avalonia.Base/Utilities/StringSplitter.cs
View File

@ -0,0 +1,114 @@
using System;
using System.Collections.Generic;
namespace Avalonia.Utilities;
/// <summary>
/// Helpers for splitting strings.
/// </summary>
internal static class StringSplitter
{
private const char DefaultOpeningParenthesis = '(';
private const char DefaultClosingParenthesis = ')';
/// <summary>
/// Splits the provided string by the specified separators, but ignores separators that
/// appear inside matching bracket pairs (<paramref name="openingBracket"/> / <paramref name="closingBracket"/>).
/// </summary>
/// <param name="s">The input string to split. If <c>null</c>, an empty array is returned.</param>
/// <param name="separator">The separator character to split on.</param>
/// <param name="openingBracket">The character that opens a bracketed section. <c>(</c> by default.</param>
/// <param name="closingBracket">The character that closes a bracketed section. <c>)</c> by default.</param>
/// <param name="options">Options for trimming entries and removing empty entries.</param>
/// <returns>An array of split segments. Returns an empty array if the input is null or only whitespace.</returns>
public static string[] SplitRespectingBrackets(string s, char separator,
char openingBracket = DefaultOpeningParenthesis, char closingBracket = DefaultClosingParenthesis,
StringSplitOptions options = StringSplitOptions.None) =>
SplitRespectingBrackets(s, [separator], openingBracket, closingBracket, options);
/// <summary>
/// Splits the provided string by the specified separator, but ignores separators that
/// appear inside matching bracket pairs (<paramref name="openingBracket"/> / <paramref name="closingBracket"/>).
/// </summary>
/// <param name="s">The input string to split. If <c>null</c>, an empty array is returned.</param>
/// <param name="separators">The separator characters to split on.</param>
/// <param name="openingBracket">The character that opens a bracketed section. <c>(</c> by default.</param>
/// <param name="closingBracket">The character that closes a bracketed section. <c>)</c> by default.</param>
/// <param name="options">Options for trimming entries and removing empty entries.</param>
/// <returns>An array of split segments. Returns an empty array if the input is null or only whitespace.</returns>
public static string[] SplitRespectingBrackets(string s, ReadOnlySpan<char> separators,
char openingBracket = DefaultOpeningParenthesis, char closingBracket = DefaultClosingParenthesis,
StringSplitOptions options = StringSplitOptions.None)
{
if (openingBracket == closingBracket)
throw new ArgumentException($"Opening bracket and closing bracket cannot be the same character '{openingBracket}'.", nameof(closingBracket));
if (s is null)
return [];
var span = s.AsSpan();
var ranges = new List<(int start, int length)>();
int depth = 0;
int segStart = 0;
bool removeEmptyEntries = options.HasFlag(StringSplitOptions.RemoveEmptyEntries);
bool trimEntries = options.HasFlag(StringSplitOptions.TrimEntries);
for (int i = 0; i < span.Length; i++)
{
char ch = span[i];
if (ch == openingBracket)
depth++;
else if (ch == closingBracket)
{
if (depth <= 0)
throw new FormatException($"Unmatched closing bracket '{closingBracket}' at position {i}.");
depth--;
}
else if (separators.Contains(ch))
{
if (depth != 0)
continue;
ProcessSegment(segStart, i - 1);
segStart = i + 1;
}
}
if (depth != 0)
throw new FormatException($"Unmatched opening bracket '{openingBracket}' in input string.");
// last segment
ProcessSegment(segStart, span.Length - 1);
if (ranges.Count == 0)
return [];
var result = new string[ranges.Count];
for (int i = 0; i < ranges.Count; i++)
{
var r = ranges[i];
#if NET6_0_OR_GREATER
result[i] = new string(span.Slice(r.start, r.length));
#else
result[i] = span.Slice(r.start, r.length).ToString();
#endif
}
return result;
void ProcessSegment(int start, int end)
{
if (trimEntries)
{
while (start <= end && char.IsWhiteSpace(s[start]))
start++;
while (end >= start && char.IsWhiteSpace(s[end]))
end--;
}
int length = end - start + 1;
if (length > 0 || !removeEmptyEntries)
ranges.Add((start, length));
}
}
}

75
tests/Avalonia.Base.UnitTests/Media/BoxShadowsTests.cs
View File

@ -0,0 +1,75 @@
using Avalonia.Media;
using Xunit;
namespace Avalonia.Base.UnitTests.Media
{
public class BoxShadowsTests
{
[Theory]
[InlineData("none")]
[InlineData(" none ")]
public void Parse_None_ReturnsEmpty(string input)
{
var bs = BoxShadows.Parse(input);
Assert.Equal(0, bs.Count);
Assert.Equal(default, bs);
Assert.Equal("none", bs.ToString());
}
[Theory]
[InlineData("0 0 5 0 #FF0000")]
[InlineData("10 20 30 5 rgba(0,0,0,0.5)")]
[InlineData("10 20 30 5 rgba(0, 0, 0, 0.5)")]
[InlineData(" 10 20 30 5 rgba(0, 0, 0, 0.5) ")]
public void Parse_SingleShadow_ToString_RoundTrip(string input)
{
var bs = BoxShadows.Parse(input);
Assert.Equal(1, bs.Count);
var str = bs.ToString();
var reparsed = BoxShadows.Parse(str);
Assert.Equal(bs, reparsed);
}
[Theory]
[InlineData("0 0 5 0 #FF0000", 10.0)]
[InlineData("0 0 10 0 rgba(0,0,0,0.5)", 20.0)]
public void TransformBounds_IncludesShadowExpansion(string input, double minExpansion)
{
var bs = BoxShadows.Parse(input);
var rect = new Rect(0, 0, 100, 100);
var transformed = bs.TransformBounds(rect);
Assert.True(transformed.Width >= rect.Width + minExpansion);
Assert.True(transformed.Height >= rect.Height + minExpansion);
}
[Theory]
[InlineData("5 5 10 0 rgba(10,20,30,0.4)")]
[InlineData("5 5 10 0 hsla(10,20%,30%,0.4)")]
[InlineData("5 5 10 0 hsva(10,20%,30%,0.4)")]
public void Parse_ColorFunction_IsHandled(string input)
{
var bs = BoxShadows.Parse(input);
Assert.Equal(1, bs.Count);
var reparsed = BoxShadows.Parse(bs.ToString());
Assert.Equal(bs, reparsed);
}
[Theory]
[InlineData("1 2 3 0 #FF0000", 1)]
[InlineData("10 20 30 5 rgba(0,0,0,0.5)", 1)]
[InlineData("1 2 3 0 #FF0000, 1 2 3 0 #FF0000", 2)]
[InlineData("10 20 30 5 rgba(0,0,0,0.5), 1 2 3 0 #FF0000", 2)]
[InlineData("10 20 30 5 rgba(0,0,0,0.5), 10 20 30 5 rgba(0,0,0,0.5)", 2)]
[InlineData("10 20 30 5 rgba(0,0,0,0.5), 10 20 30 5 rgba(0,0,0,0.5), 10 20 30 5 rgba(0,0,0,0.5)", 3)]
[InlineData("10 20 30 5 rgba(0,0,0,0.5), 10 20 30 5 #ffffff, 10 20 30 5 Red", 3)]
[InlineData(" 10 20 30 5 rgba(0, 0, 0, 0.5), 10 20 30 5 rgba(0, 0, 0, 0.5), 10 20 30 5 rgba(0, 0, 0, 0.5) ", 3)]
[InlineData(" 10 20 30 5 rgba(0, 0, 0, 0.5), 10 20 30 5 #ffffff, 10 20 30 5 Red ", 3)]
public void Parse_MultipleShadows(string input, int count)
{
var bs = BoxShadows.Parse(input);
Assert.Equal(count, bs.Count);
var reparsed = BoxShadows.Parse(bs.ToString());
Assert.Equal(bs, reparsed);
}
}
}

175
tests/Avalonia.Base.UnitTests/Utilities/StringSplitterTests.cs
View File

@ -0,0 +1,175 @@
using System;
using System.Collections.Generic;
using Avalonia.Utilities;
using Xunit;
namespace Avalonia.Base.UnitTests.Utilities;
public class StringSplitterTests
{
#region Tests without brackets - should match string.Split behavior
[Fact]
public void SplitRespectingBrackets_WithoutBrackets_NullReturnsEmptyArray()
{
var result = StringSplitter.SplitRespectingBrackets(null, ',');
Assert.Empty(result);
}
[Theory]
[InlineData("")]
[InlineData(" ")]
[InlineData("\t\n")]
[InlineData("abc")]
[InlineData("a,b,c")]
[InlineData("a,,c")]
[InlineData("a,,,b")]
[InlineData(",a,b,")]
[InlineData(" a , b , c ")]
[InlineData(" a ,,,, c ")]
[InlineData(" a , , c ")]
[InlineData(" a, b ,c ")]
[InlineData(" , a , b , ")]
[InlineData(" a , b , c ")]
[InlineData("First,Second,Third")]
[InlineData("Header\nBody\nFooter\n", '\n')]
[InlineData("Width;Height;Margin;Padding", ';')]
[InlineData("Avalonia.Utilities.StringSplitter", '.')]
public void SplitRespectingBrackets_WithoutBrackets_SingleSeparator(string input, char separator = ',')
{
foreach (var options in EnumerateStringSplitOptionsCombinations())
{
var result = StringSplitter.SplitRespectingBrackets(input, separator, options: options);
var expected = input.Split(separator, options);
Assert.Equal(expected, result);
}
}
[Theory]
[InlineData("a,b;c,d")]
[InlineData("a,b;,;c,d")]
[InlineData(" a , b ; c , d ")]
[InlineData(" a , b ; ; c , d ")]
[InlineData(" a , b ;,; c , d ")]
[InlineData(" ; a , b ; c , d ; ")]
public void SplitRespectingBrackets_WithoutBrackets_MultipleSeparators(string input)
{
char[] separators = [',', ';'];
foreach (var options in EnumerateStringSplitOptionsCombinations())
{
var result = StringSplitter.SplitRespectingBrackets(input, separators, options: options);
var expected = input.Split(separators, options);
Assert.Equal(expected, result);
}
}
#endregion
#region Tests with brackets - should respect bracket pairs
[Theory]
[InlineData("(a)(b,c)", new[] { "(a)(b,c)" })]
[InlineData("a,(),b", new[] { "a", "()", "b" })]
[InlineData("a,(b,c),d", new[] { "a", "(b,c)", "d" })]
[InlineData("a,(b,(c,d)),e", new[] { "a", "(b,(c,d))", "e" })]
[InlineData(",a,(b,c),d,", new[] { "", "a", "(b,c)", "d", "" })]
[InlineData("(a,b),(c,d),(e,f)", new[] { "(a,b)", "(c,d)", "(e,f)" })]
[InlineData("a,(b,(c,(d,e))),f", new[] { "a", "(b,(c,(d,e)))", "f" })]
[InlineData("Button,TextBox(Width=100,Height=50),Label", new[] { "Button", "TextBox(Width=100,Height=50)", "Label" })]
[InlineData("string,List(int),Dictionary(string,object)", new[] { "string", "List(int)", "Dictionary(string,object)" })]
[InlineData("FirstItem,Item(param1,param2,param3),x,VeryLongItemName(a,b),Short", new[] { "FirstItem", "Item(param1,param2,param3)", "x", "VeryLongItemName(a,b)", "Short" })]
[InlineData("BindingPath,Converter(Type=MyConverter,Parameter=Value123),Mode=TwoWay", new[] { "BindingPath", "Converter(Type=MyConverter,Parameter=Value123)", "Mode=TwoWay" })]
[InlineData("Observable(List(Dictionary(string,int))),SimpleType,AnotherObservable(string)", new[] { "Observable(List(Dictionary(string,int)))", "SimpleType", "AnotherObservable(string)" })]
[InlineData("OuterType(InnerType(DeepType(VeryDeepValue1,VeryDeepValue2),InnerValue),OuterValue)", new[] { "OuterType(InnerType(DeepType(VeryDeepValue1,VeryDeepValue2),InnerValue),OuterValue)" })]
[InlineData("0 4 6 -1 #FF000000,0 2 4 -1 rgba(0,0,0,0.06),inset 0 1 2 0 rgba(255,255,255,0.1)", new[] { "0 4 6 -1 #FF000000", "0 2 4 -1 rgba(0,0,0,0.06)", "inset 0 1 2 0 rgba(255,255,255,0.1)" })]
public void SplitRespectingBrackets_WithBrackets_DefaultBrackets(string input, string[] expected)
{
var result = StringSplitter.SplitRespectingBrackets(input, ',');
Assert.Equal(expected, result);
}
[Theory]
[InlineData("a,(b,c;d);e", new[] { "a", "(b,c;d)", "e" })]
[InlineData("Width=100,Height=200;Margin(10;20;30;40),Padding=5", new[] { "Width=100", "Height=200", "Margin(10;20;30;40)", "Padding=5" })]
public void SplitRespectingBrackets_WithBrackets_MultipleSeparators(string input, string[] expected)
{
var result = StringSplitter.SplitRespectingBrackets(input, [',', ';']);
Assert.Equal(expected, result);
}
[Theory]
[InlineData("a,(b,c),d", '[', ']', new[] { "a", "(b", "c)", "d" })]
[InlineData("a,[b,c],d", '[', ']', new[] { "a", "[b,c]", "d" })]
[InlineData("x,<y,z>,w", '<', '>', new[] { "x", "<y,z>", "w" })]
[InlineData("Property1,Property2[Index1,Index2],Property3", '[', ']', new[] { "Property1", "Property2[Index1,Index2]", "Property3" })]
public void SplitRespectingBrackets_WithBrackets_CustomBrackets(string input, char openingBracket, char closingBracket, string[] expected)
{
var result = StringSplitter.SplitRespectingBrackets(input, ',', openingBracket, closingBracket);
Assert.Equal(expected, result);
}
[Theory]
[InlineData("a,,(b,c),,d", StringSplitOptions.None, new[] { "a", "", "(b,c)", "", "d" })]
[InlineData("a,,(b,c),,d", StringSplitOptions.RemoveEmptyEntries, new[] { "a", "(b,c)", "d" })]
[InlineData(",a,(b,c),d,", StringSplitOptions.None, new[] { "", "a", "(b,c)", "d", "" })]
[InlineData(",a,(b,c),d,", StringSplitOptions.RemoveEmptyEntries, new[] { "a", "(b,c)", "d" })]
[InlineData(" a , (b, c) , d ", StringSplitOptions.None, new[] { " a ", " (b, c) ", " d " })]
[InlineData(" a , (b, c) , d ", StringSplitOptions.TrimEntries, new[] { "a", "(b, c)", "d" })]
[InlineData(" a , , (b, c) , , d ", StringSplitOptions.None, new[] { " a ", " ", " (b, c) ", " ", " d " })]
[InlineData(" a , , (b, c) , , d ", StringSplitOptions.TrimEntries, new[] { "a", "", "(b, c)", "", "d" })]
[InlineData(" a , , (b, c) , , d ", StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries, new[] { "a", "(b, c)", "d" })]
[InlineData(" , a , ( b , ( c , d ) ) , , e , ", StringSplitOptions.None, new[] { " ", " a ", " ( b , ( c , d ) ) ", " ", " e ", " " })]
[InlineData(" , a , ( b , ( c , d ) ) , , e , ", StringSplitOptions.TrimEntries, new[] { "", "a", "( b , ( c , d ) )", "", "e", "" })]
[InlineData(" , a , ( b , ( c , d ) ) , , e , ", StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries, new[] { "a", "( b , ( c , d ) )", "e" })]
public void SplitRespectingBrackets_WithBrackets_WithOptions(string input, StringSplitOptions options, string[] expected)
{
var result = StringSplitter.SplitRespectingBrackets(input, ',', options: options);
Assert.Equal(expected, result);
}
#endregion
#region Tests for mismatched brackets - should throw exceptions
[Theory]
[InlineData("(")]
[InlineData(")")]
[InlineData(")a,b(")]
[InlineData("a,b),c")]
[InlineData("a,(b,c")]
[InlineData("a,b))c")]
[InlineData("a,((b,c)")]
[InlineData("a,(b,(c)),d)")]
[InlineData("x,[y,z", '[', ']')]
[InlineData("x,y],z", '[', ']')]
[InlineData("Type1,Type2(Inner1,Inner2)),Type3")]
[InlineData("Property1,Property2(Parameter1,Parameter2,Property3")]
[InlineData("OuterType(InnerType(DeepType(Value1,Value2),MiddleType(Value3)")]
public void SplitRespectingBrackets_UnmatchedBrackets_ThrowsFormatException(string input, char openingBracket = '(', char closingBracket = ')')
{
Assert.Throws<FormatException>(() =>
StringSplitter.SplitRespectingBrackets(input, ',', openingBracket, closingBracket));
}
[Theory]
[InlineData('(', '(')]
[InlineData('[', '[')]
[InlineData('.', '.')]
public void SplitRespectingBrackets_SameOpeningAndClosingBracket_ThrowsArgumentException(char bracket1, char bracket2)
{
var input = "a,b,c";
Assert.Throws<ArgumentException>(() =>
StringSplitter.SplitRespectingBrackets(input, ',', bracket1, bracket2));
}
#endregion
private static IEnumerable<StringSplitOptions> EnumerateStringSplitOptionsCombinations()
{
yield return StringSplitOptions.None;
yield return StringSplitOptions.RemoveEmptyEntries;
yield return StringSplitOptions.TrimEntries;
yield return StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries;
}
}
Write Preview
Loading…
Cancel
Save