13888006503

Committed 16 Mar 2025 10:28PM UTC coverage: 55.929% (-0.1%) from 56.036%

Build # 13888006503

Build Type

push

github

Committed by

web-flow

Commit Message

[TASK] Avoid the deprecated `__toString()` in tests (#1180)

Moving some tests to functional tests and splitting them up
will come in later changes for #1057.

Run Details

1047 of 1872 relevant lines covered (55.93%)

12.64 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.19

/src/Value/Color.php

<?php

declare(strict_types=1);

namespace Sabberworm\CSS\Value;

use Sabberworm\CSS\OutputFormat;
use Sabberworm\CSS\Parsing\ParserState;
use Sabberworm\CSS\Parsing\UnexpectedEOFException;
use Sabberworm\CSS\Parsing\UnexpectedTokenException;

/**
 * `Color's can be input in the form #rrggbb, #rgb or schema(val1, val2, …) but are always stored as an array of
 * ('s' => val1, 'c' => val2, 'h' => val3, …) and output in the second form.
 */
class Color extends CSSFunction
{
    /**
     * @param array<array-key, Value|string> $colorValues
     * @param int<0, max> $lineNumber
     */
    public function __construct(array $colorValues, int $lineNumber = 0)
    {
        parent::__construct(\implode('', \array_keys($colorValues)), $colorValues, ',', $lineNumber);
    }

    /**
     * @throws UnexpectedEOFException
     * @throws UnexpectedTokenException
     *
     * @internal since V8.8.0
     */
    public static function parse(ParserState $parserState, bool $ignoreCase = false): CSSFunction
    {
        return
            $parserState->comes('#')
                ? self::parseHexColor($parserState)
                : self::parseColorFunction($parserState);
    }

    /**
     * @throws UnexpectedEOFException
     * @throws UnexpectedTokenException
     */
    private static function parseHexColor(ParserState $parserState): CSSFunction
    {
        $parserState->consume('#');
        $hexValue = $parserState->parseIdentifier(false);
        if ($parserState->strlen($hexValue) === 3) {
            $hexValue = $hexValue[0] . $hexValue[0] . $hexValue[1] . $hexValue[1] . $hexValue[2] . $hexValue[2];
        } elseif ($parserState->strlen($hexValue) === 4) {
            $hexValue = $hexValue[0] . $hexValue[0] . $hexValue[1] . $hexValue[1] . $hexValue[2] . $hexValue[2]
                . $hexValue[3] . $hexValue[3];
        }

        if ($parserState->strlen($hexValue) === 8) {
            $colorValues = [
                'r' => new Size(\intval($hexValue[0] . $hexValue[1], 16), null, true, $parserState->currentLine()),
                'g' => new Size(\intval($hexValue[2] . $hexValue[3], 16), null, true, $parserState->currentLine()),
                'b' => new Size(\intval($hexValue[4] . $hexValue[5], 16), null, true, $parserState->currentLine()),
                'a' => new Size(
                    \round(self::mapRange(\intval($hexValue[6] . $hexValue[7], 16), 0, 255, 0, 1), 2),
                    null,
                    true,
                    $parserState->currentLine()
                ),
            ];
        } elseif ($parserState->strlen($hexValue) === 6) {
            $colorValues = [
                'r' => new Size(\intval($hexValue[0] . $hexValue[1], 16), null, true, $parserState->currentLine()),
                'g' => new Size(\intval($hexValue[2] . $hexValue[3], 16), null, true, $parserState->currentLine()),
                'b' => new Size(\intval($hexValue[4] . $hexValue[5], 16), null, true, $parserState->currentLine()),
            ];
        } else {
            throw new UnexpectedTokenException(
                'Invalid hex color value',
                $hexValue,
                'custom',
                $parserState->currentLine()
            );
        }

        return new Color($colorValues, $parserState->currentLine());
    }

    /**
     * @throws UnexpectedEOFException
     * @throws UnexpectedTokenException
     */
    private static function parseColorFunction(ParserState $parserState): CSSFunction
    {
        $colorValues = [];

        $colorMode = $parserState->parseIdentifier(true);
        $parserState->consumeWhiteSpace();
        $parserState->consume('(');

        // CSS Color Module Level 4 says that `rgb` and `rgba` are now aliases; likewise `hsl` and `hsla`.
        // So, attempt to parse with the `a`, and allow for it not being there.
        switch ($colorMode) {
            case 'rgb':
                $colorModeForParsing = 'rgba';
                $mayHaveOptionalAlpha = true;
                break;
            case 'hsl':
                $colorModeForParsing = 'hsla';
                $mayHaveOptionalAlpha = true;
                break;
            case 'rgba':
                // This is handled identically to the following case.
            case 'hsla':
                $colorModeForParsing = $colorMode;
                $mayHaveOptionalAlpha = true;
                break;
            default:
                $colorModeForParsing = $colorMode;
                $mayHaveOptionalAlpha = false;
        }

        $containsVar = false;
        $containsNone = false;
        $isLegacySyntax = false;
        $expectedArgumentCount = $parserState->strlen($colorModeForParsing);
        for ($argumentIndex = 0; $argumentIndex < $expectedArgumentCount; ++$argumentIndex) {
            $parserState->consumeWhiteSpace();
            $valueKey = $colorModeForParsing[$argumentIndex];
            if ($parserState->comes('var')) {
                $colorValues[$valueKey] = CSSFunction::parseIdentifierOrFunction($parserState);
                $containsVar = true;
            } elseif (!$isLegacySyntax && $parserState->comes('none')) {
                $colorValues[$valueKey] = $parserState->parseIdentifier();
                $containsNone = true;
            } else {
                $colorValues[$valueKey] = Size::parse($parserState, true);
            }

            // This must be done first, to consume comments as well, so that the `comes` test will work.
            $parserState->consumeWhiteSpace();

            // With a `var` argument, the function can have fewer arguments.
            // And as of CSS Color Module Level 4, the alpha argument is optional.
            $canCloseNow =
                $containsVar
                || ($mayHaveOptionalAlpha && $argumentIndex >= $expectedArgumentCount - 2);
            if ($canCloseNow && $parserState->comes(')')) {
                break;
            }

            // "Legacy" syntax is comma-delimited, and does not allow the `none` keyword.
            // "Modern" syntax is space-delimited, with `/` as alpha delimiter.
            // They cannot be mixed.
            if ($argumentIndex === 0 && !$containsNone) {
                // An immediate closing parenthesis is not valid.
                if ($parserState->comes(')')) {
                    throw new UnexpectedTokenException(
                        'Color function with no arguments',
                        '',
                        'custom',
                        $parserState->currentLine()
                    );
                }
                $isLegacySyntax = $parserState->comes(',');
            }

            if ($isLegacySyntax && $argumentIndex < ($expectedArgumentCount - 1)) {
                $parserState->consume(',');
            }

            // In the "modern" syntax, the alpha value must be delimited with `/`.
            if (!$isLegacySyntax) {
                if ($containsVar) {
                    // If the `var` substitution encompasses more than one argument,
                    // the alpha deliminator may come at any time.
                    if ($parserState->comes('/')) {
                        $parserState->consume('/');
                    }
                } elseif (($colorModeForParsing[$argumentIndex + 1] ?? '') === 'a') {
                    // Alpha value is the next expected argument.
                    // Since a closing parenthesis was not found, a `/` separator is now required.
                    $parserState->consume('/');
                }
            }
        }
        $parserState->consume(')');

        return
            $containsVar
                ? new CSSFunction($colorMode, \array_values($colorValues), ',', $parserState->currentLine())
                : new Color($colorValues, $parserState->currentLine());
    }

    private static function mapRange(float $value, float $fromMin, float $fromMax, float $toMin, float $toMax): float
    {
        $fromRange = $fromMax - $fromMin;
        $toRange = $toMax - $toMin;
        $multiplier = $toRange / $fromRange;
        $newValue = $value - $fromMin;
        $newValue *= $multiplier;
        return $newValue + $toMin;
    }

    /**
     * @return array<array-key, Value|string>
     */
    public function getColor()
    {
        return $this->components;
    }

    /**
     * @param array<array-key, Value|string> $colorValues
     */
    public function setColor(array $colorValues): void
    {
        $this->setName(\implode('', \array_keys($colorValues)));
        $this->components = $colorValues;
    }

    /**
     * @return string
     */
    public function getColorDescription()
    {
        return $this->getName();
    }

    /**
     * @deprecated in V8.8.0, will be removed in V9.0.0. Use `render` instead.
     */
    public function __toString(): string
    {
        return $this->render(new OutputFormat());
    }

    public function render(OutputFormat $outputFormat): string
    {
        if ($this->shouldRenderAsHex($outputFormat)) {
            return $this->renderAsHex();
        }

        if ($this->shouldRenderInModernSyntax()) {
            return $this->renderInModernSyntax($outputFormat);
        }

        return parent::render($outputFormat);
    }

    private function shouldRenderAsHex(OutputFormat $outputFormat): bool
    {
        return
            $outputFormat->usesRgbHashNotation()
            && $this->getRealName() === 'rgb'
            && $this->allComponentsAreNumbers();
    }

    /**
     * The function name is a concatenation of the array keys of the components, which is passed to the constructor.
     * However, this can be changed by calling {@see CSSFunction::setName},
     * so is not reliable in situations where it's necessary to determine the function name based on the components.
     */
    private function getRealName(): string
    {
        return \implode('', \array_keys($this->components));
    }

    /**
     * Test whether all color components are absolute numbers (CSS type `number`), not percentages or anything else.
     * If any component is not an instance of `Size`, the method will also return `false`.
     */
    private function allComponentsAreNumbers(): bool
    {
        foreach ($this->components as $component) {
            if (!($component instanceof Size) || $component->getUnit() !== null) {
                return false;
            }
        }

        return true;
    }

    /**
     * Note that this method assumes the following:
     * - The `components` array has keys for `r`, `g` and `b`;
     * - The values in the array are all instances of `Size`.
     *
     * Errors will be triggered or thrown if this is not the case.
     *
     * @return non-empty-string
     */
    private function renderAsHex(): string
    {
        $result = \sprintf(
            '%02x%02x%02x',
            $this->components['r']->getSize(),
            $this->components['g']->getSize(),
            $this->components['b']->getSize()
        );
        $canUseShortVariant = ($result[0] == $result[1]) && ($result[2] == $result[3]) && ($result[4] == $result[5]);

        return '#' . ($canUseShortVariant ? $result[0] . $result[2] . $result[4] : $result);
    }

    /**
     * The "legacy" syntax does not allow RGB colors to have a mixture of `percentage`s and `number`s,
     * and does not allow `none` as any component value.
     *
     * The "legacy" and "modern" monikers are part of the formal W3C syntax.
     * See the following for more information:
     * - {@link
     *     https://developer.mozilla.org/en-US/docs/Web/CSS/color_value/rgb#formal_syntax
     *     Description of the formal syntax for `rgb()` on MDN
     *   };
     * - {@link
     *     https://www.w3.org/TR/css-color-4/#rgb-functions
     *     The same in the CSS Color Module Level 4 W3C Candidate Recommendation Draft
     *   } (as of 13 February 2024, at time of writing).
     */
    private function shouldRenderInModernSyntax(): bool
    {
        if ($this->hasNoneAsComponentValue()) {
            return true;
        }

        if (!$this->colorFunctionMayHaveMixedValueTypes($this->getRealName())) {
            return false;
        }

        $hasPercentage = false;
        $hasNumber = false;
        foreach ($this->components as $key => $value) {
            if ($key === 'a') {
                // Alpha can have units that don't match those of the RGB components in the "legacy" syntax.
                // So it is not necessary to check it.  It's also always last, hence `break` rather than `continue`.
                break;
            }
            if (!($value instanceof Size)) {
                // Unexpected, unknown, or modified via the API
                return false;
            }
            $unit = $value->getUnit();
            // `switch` only does loose comparison
            if ($unit === null) {
                $hasNumber = true;
            } elseif ($unit === '%') {
                $hasPercentage = true;
            } else {
                // Invalid unit
                return false;
            }
        }

        return $hasPercentage && $hasNumber;
    }

    private function hasNoneAsComponentValue(): bool
    {
        return \in_array('none', $this->components, true);
    }

    /**
     * Some color functions, such as `rgb`,
     * may have a mixture of `percentage`, `number`, or possibly other types in their arguments.
     *
     * Note that this excludes the alpha component, which is treated separately.
     */
    private function colorFunctionMayHaveMixedValueTypes(string $function): bool
    {
        $functionsThatMayHaveMixedValueTypes = ['rgb', 'rgba'];

        return \in_array($function, $functionsThatMayHaveMixedValueTypes, true);
    }

    /**
     * @return non-empty-string
     */
    private function renderInModernSyntax(OutputFormat $outputFormat): string
    {
        // Maybe not yet without alpha, but will be...
        $componentsWithoutAlpha = $this->components;
        \end($componentsWithoutAlpha);
        if (\key($componentsWithoutAlpha) === 'a') {
            $alpha = $this->components['a'];
            unset($componentsWithoutAlpha['a']);
        }

        $formatter = $outputFormat->getFormatter();
        $arguments = $formatter->implode(' ', $componentsWithoutAlpha);
        if (isset($alpha)) {
            $separator = $formatter->spaceBeforeListArgumentSeparator('/')
                . '/' . $formatter->spaceAfterListArgumentSeparator('/');
            $arguments = $formatter->implode($separator, [$arguments, $alpha]);
        }

        return $this->getName() . '(' . $arguments . ')';
    }
}

1	<?php
2
3	declare(strict_types=1);
4
5	namespace Sabberworm\CSS\Value;
6
7	use Sabberworm\CSS\OutputFormat;
8	use Sabberworm\CSS\Parsing\ParserState;
9	use Sabberworm\CSS\Parsing\UnexpectedEOFException;
10	use Sabberworm\CSS\Parsing\UnexpectedTokenException;
11
12	/**
13	* `Color's can be input in the form #rrggbb, #rgb or schema(val1, val2, …) but are always stored as an array of
14	* ('s' => val1, 'c' => val2, 'h' => val3, …) and output in the second form.
15	*/
16	class Color extends CSSFunction
17	{
18	/**
19	* @param array<array-key, Value\|string> $colorValues
20	* @param int<0, max> $lineNumber
21	*/
22	public function __construct(array $colorValues, int $lineNumber = 0)	62✔
23	{
24	parent::__construct(\implode('', \array_keys($colorValues)), $colorValues, ',', $lineNumber);	62✔
25	}	62✔
26
27	/**
28	* @throws UnexpectedEOFException
29	* @throws UnexpectedTokenException
30	*
31	* @internal since V8.8.0
32	*/
33	public static function parse(ParserState $parserState, bool $ignoreCase = false): CSSFunction	121✔
34	{
35	return
36	$parserState->comes('#')	121✔
37	? self::parseHexColor($parserState)	23✔
38	: self::parseColorFunction($parserState);	113✔
39	}
40
41	/**
42	* @throws UnexpectedEOFException
43	* @throws UnexpectedTokenException
44	*/
45	private static function parseHexColor(ParserState $parserState): CSSFunction	23✔
46	{
47	$parserState->consume('#');	23✔
48	$hexValue = $parserState->parseIdentifier(false);	23✔
49	if ($parserState->strlen($hexValue) === 3) {	22✔
50	$hexValue = $hexValue[0] . $hexValue[0] . $hexValue[1] . $hexValue[1] . $hexValue[2] . $hexValue[2];	6✔
51	} elseif ($parserState->strlen($hexValue) === 4) {	18✔
52	$hexValue = $hexValue[0] . $hexValue[0] . $hexValue[1] . $hexValue[1] . $hexValue[2] . $hexValue[2]	3✔
53	. $hexValue[3] . $hexValue[3];	3✔
54	}
55
56	if ($parserState->strlen($hexValue) === 8) {	22✔
57	$colorValues = [
58	'r' => new Size(\intval($hexValue[0] . $hexValue[1], 16), null, true, $parserState->currentLine()),	4✔
59	'g' => new Size(\intval($hexValue[2] . $hexValue[3], 16), null, true, $parserState->currentLine()),	4✔
60	'b' => new Size(\intval($hexValue[4] . $hexValue[5], 16), null, true, $parserState->currentLine()),	4✔
61	'a' => new Size(	4✔
62	\round(self::mapRange(\intval($hexValue[6] . $hexValue[7], 16), 0, 255, 0, 1), 2),	4✔
63	null,	4✔
64	true,	4✔
65	$parserState->currentLine()	4✔
66	),
67	];
68	} elseif ($parserState->strlen($hexValue) === 6) {	19✔
69	$colorValues = [
70	'r' => new Size(\intval($hexValue[0] . $hexValue[1], 16), null, true, $parserState->currentLine()),	12✔
71	'g' => new Size(\intval($hexValue[2] . $hexValue[3], 16), null, true, $parserState->currentLine()),	12✔
72	'b' => new Size(\intval($hexValue[4] . $hexValue[5], 16), null, true, $parserState->currentLine()),	12✔
73	];
74	} else {
75	throw new UnexpectedTokenException(	9✔
76	'Invalid hex color value',	9✔
77	$hexValue,
78	'custom',	9✔
79	$parserState->currentLine()	9✔
80	);
81	}
82
83	return new Color($colorValues, $parserState->currentLine());	15✔
84	}
85
86	/**
87	* @throws UnexpectedEOFException
88	* @throws UnexpectedTokenException
89	*/
90	private static function parseColorFunction(ParserState $parserState): CSSFunction	102✔
91	{
92	$colorValues = [];	102✔
93
94	$colorMode = $parserState->parseIdentifier(true);	102✔
95	$parserState->consumeWhiteSpace();	102✔
96	$parserState->consume('(');	102✔
97
98	// CSS Color Module Level 4 says that `rgb` and `rgba` are now aliases; likewise `hsl` and `hsla`.
99	// So, attempt to parse with the `a`, and allow for it not being there.
100	switch ($colorMode) {	102✔
101	case 'rgb':	102✔
102	$colorModeForParsing = 'rgba';	49✔
103	$mayHaveOptionalAlpha = true;	49✔
104	break;	49✔
105	case 'hsl':	56✔
106	$colorModeForParsing = 'hsla';	26✔
107	$mayHaveOptionalAlpha = true;	26✔
108	break;	26✔
109	case 'rgba':	32✔
110	// This is handled identically to the following case.
111	case 'hsla':	5✔
112	$colorModeForParsing = $colorMode;	32✔
113	$mayHaveOptionalAlpha = true;	32✔
114	break;	32✔
115	default:
116	$colorModeForParsing = $colorMode;	×
117	$mayHaveOptionalAlpha = false;	×
118	}
119
120	$containsVar = false;	102✔
121	$containsNone = false;	102✔
122	$isLegacySyntax = false;	102✔
123	$expectedArgumentCount = $parserState->strlen($colorModeForParsing);	102✔
124	for ($argumentIndex = 0; $argumentIndex < $expectedArgumentCount; ++$argumentIndex) {	102✔
125	$parserState->consumeWhiteSpace();	102✔
126	$valueKey = $colorModeForParsing[$argumentIndex];	102✔
127	if ($parserState->comes('var')) {	102✔
128	$colorValues[$valueKey] = CSSFunction::parseIdentifierOrFunction($parserState);	31✔
129	$containsVar = true;	31✔
130	} elseif (!$isLegacySyntax && $parserState->comes('none')) {	101✔
131	$colorValues[$valueKey] = $parserState->parseIdentifier();	10✔
132	$containsNone = true;	10✔
133	} else {
134	$colorValues[$valueKey] = Size::parse($parserState, true);	101✔
135	}
136
137	// This must be done first, to consume comments as well, so that the `comes` test will work.
138	$parserState->consumeWhiteSpace();	102✔
139
140	// With a `var` argument, the function can have fewer arguments.
141	// And as of CSS Color Module Level 4, the alpha argument is optional.
142	$canCloseNow =
143	$containsVar	102✔
144	\|\| ($mayHaveOptionalAlpha && $argumentIndex >= $expectedArgumentCount - 2);	102✔
145	if ($canCloseNow && $parserState->comes(')')) {	102✔
146	break;	80✔
147	}
148
149	// "Legacy" syntax is comma-delimited, and does not allow the `none` keyword.
150	// "Modern" syntax is space-delimited, with `/` as alpha delimiter.
151	// They cannot be mixed.
152	if ($argumentIndex === 0 && !$containsNone) {	101✔
153	// An immediate closing parenthesis is not valid.
154	if ($parserState->comes(')')) {	97✔
155	throw new UnexpectedTokenException(	4✔
156	'Color function with no arguments',	4✔
157	'',	4✔
158	'custom',	4✔
159	$parserState->currentLine()	4✔
160	);
161	}
162	$isLegacySyntax = $parserState->comes(',');	93✔
163	}
164
165	if ($isLegacySyntax && $argumentIndex < ($expectedArgumentCount - 1)) {	97✔
166	$parserState->consume(',');	52✔
167	}
168
169	// In the "modern" syntax, the alpha value must be delimited with `/`.
170	if (!$isLegacySyntax) {	97✔
171	if ($containsVar) {	45✔
172	// If the `var` substitution encompasses more than one argument,
173	// the alpha deliminator may come at any time.
174	if ($parserState->comes('/')) {	9✔
175	$parserState->consume('/');	9✔
176	}
177	} elseif (($colorModeForParsing[$argumentIndex + 1] ?? '') === 'a') {	40✔
178	// Alpha value is the next expected argument.
179	// Since a closing parenthesis was not found, a `/` separator is now required.
180	$parserState->consume('/');	17✔
181	}
182	}
183	}
184	$parserState->consume(')');	84✔
185
186	return
187	$containsVar	80✔
188	? new CSSFunction($colorMode, \array_values($colorValues), ',', $parserState->currentLine())	31✔
189	: new Color($colorValues, $parserState->currentLine());	80✔
190	}
191
192	private static function mapRange(float $value, float $fromMin, float $fromMax, float $toMin, float $toMax): float	4✔
193	{
194	$fromRange = $fromMax - $fromMin;	4✔
195	$toRange = $toMax - $toMin;	4✔
196	$multiplier = $toRange / $fromRange;	4✔
197	$newValue = $value - $fromMin;	4✔
198	$newValue *= $multiplier;	4✔
199	return $newValue + $toMin;	4✔
200	}
201
202	/**
203	* @return array<array-key, Value\|string>
204	*/
205	public function getColor()	2✔
206	{
207	return $this->components;	2✔
208	}
209
210	/**
211	* @param array<array-key, Value\|string> $colorValues
212	*/
213	public function setColor(array $colorValues): void	×
214	{
215	$this->setName(\implode('', \array_keys($colorValues)));	×
216	$this->components = $colorValues;	×
217	}	×
218
219	/**
220	* @return string
221	*/
222	public function getColorDescription()	1✔
223	{
224	return $this->getName();	1✔
225	}
226
227	/**
228	* @deprecated in V8.8.0, will be removed in V9.0.0. Use `render` instead.
229	*/
230	public function __toString(): string	×
231	{
232	return $this->render(new OutputFormat());	×
233	}
234
235	public function render(OutputFormat $outputFormat): string	59✔
236	{
237	if ($this->shouldRenderAsHex($outputFormat)) {	59✔
238	return $this->renderAsHex();	15✔
239	}
240
241	if ($this->shouldRenderInModernSyntax()) {	48✔
242	return $this->renderInModernSyntax($outputFormat);	17✔
243	}
244
245	return parent::render($outputFormat);	31✔
246	}
247
248	private function shouldRenderAsHex(OutputFormat $outputFormat): bool	59✔
249	{
250	return
251	$outputFormat->usesRgbHashNotation()	59✔
252	&& $this->getRealName() === 'rgb'	59✔
253	&& $this->allComponentsAreNumbers();	59✔
254	}
255
256	/**
257	* The function name is a concatenation of the array keys of the components, which is passed to the constructor.
258	* However, this can be changed by calling {@see CSSFunction::setName},
259	* so is not reliable in situations where it's necessary to determine the function name based on the components.
260	*/
261	private function getRealName(): string	59✔
262	{
263	return \implode('', \array_keys($this->components));	59✔
264	}
265
266	/**
267	* Test whether all color components are absolute numbers (CSS type `number`), not percentages or anything else.
268	* If any component is not an instance of `Size`, the method will also return `false`.
269	*/
270	private function allComponentsAreNumbers(): bool	26✔
271	{
272	foreach ($this->components as $component) {	26✔
273	if (!($component instanceof Size) \|\| $component->getUnit() !== null) {	26✔
274	return false;	11✔
275	}
276	}
277
278	return true;	15✔
279	}
280
281	/**
282	* Note that this method assumes the following:
283	* - The `components` array has keys for `r`, `g` and `b`;
284	* - The values in the array are all instances of `Size`.
285	*
286	* Errors will be triggered or thrown if this is not the case.
287	*
288	* @return non-empty-string
289	*/
290	private function renderAsHex(): string	15✔
291	{
292	$result = \sprintf(	15✔
293	'%02x%02x%02x',	15✔
294	$this->components['r']->getSize(),	15✔
295	$this->components['g']->getSize(),	15✔
296	$this->components['b']->getSize()	15✔
297	);
298	$canUseShortVariant = ($result[0] == $result[1]) && ($result[2] == $result[3]) && ($result[4] == $result[5]);	15✔
299
300	return '#' . ($canUseShortVariant ? $result[0] . $result[2] . $result[4] : $result);	15✔
301	}
302
303	/**
304	* The "legacy" syntax does not allow RGB colors to have a mixture of `percentage`s and `number`s,
305	* and does not allow `none` as any component value.
306	*
307	* The "legacy" and "modern" monikers are part of the formal W3C syntax.
308	* See the following for more information:
309	* - {@link
310	* https://developer.mozilla.org/en-US/docs/Web/CSS/color_value/rgb#formal_syntax
311	* Description of the formal syntax for `rgb()` on MDN
312	* };
313	* - {@link
314	* https://www.w3.org/TR/css-color-4/#rgb-functions
315	* The same in the CSS Color Module Level 4 W3C Candidate Recommendation Draft
316	* } (as of 13 February 2024, at time of writing).
317	*/
318	private function shouldRenderInModernSyntax(): bool	48✔
319	{
320	if ($this->hasNoneAsComponentValue()) {	48✔
321	return true;	8✔
322	}
323
324	if (!$this->colorFunctionMayHaveMixedValueTypes($this->getRealName())) {	40✔
325	return false;	15✔
326	}
327
328	$hasPercentage = false;	27✔
329	$hasNumber = false;	27✔
330	foreach ($this->components as $key => $value) {	27✔
331	if ($key === 'a') {	27✔
332	// Alpha can have units that don't match those of the RGB components in the "legacy" syntax.
333	// So it is not necessary to check it. It's also always last, hence `break` rather than `continue`.
334	break;	19✔
335	}
336	if (!($value instanceof Size)) {	27✔
337	// Unexpected, unknown, or modified via the API
338	return false;	×
339	}
340	$unit = $value->getUnit();	27✔
341	// `switch` only does loose comparison
342	if ($unit === null) {	27✔
343	$hasNumber = true;	21✔
344	} elseif ($unit === '%') {	15✔
345	$hasPercentage = true;	15✔
346	} else {
347	// Invalid unit
348	return false;	×
349	}
350	}
351
352	return $hasPercentage && $hasNumber;	27✔
353	}
354
355	private function hasNoneAsComponentValue(): bool	48✔
356	{
357	return \in_array('none', $this->components, true);	48✔
358	}
359
360	/**
361	* Some color functions, such as `rgb`,
362	* may have a mixture of `percentage`, `number`, or possibly other types in their arguments.
363	*
364	* Note that this excludes the alpha component, which is treated separately.
365	*/
366	private function colorFunctionMayHaveMixedValueTypes(string $function): bool	40✔
367	{
368	$functionsThatMayHaveMixedValueTypes = ['rgb', 'rgba'];	40✔
369
370	return \in_array($function, $functionsThatMayHaveMixedValueTypes, true);	40✔
371	}
372
373	/**
374	* @return non-empty-string
375	*/
376	private function renderInModernSyntax(OutputFormat $outputFormat): string	17✔
377	{
378	// Maybe not yet without alpha, but will be...
379	$componentsWithoutAlpha = $this->components;	17✔
380	\end($componentsWithoutAlpha);	17✔
381	if (\key($componentsWithoutAlpha) === 'a') {	17✔
382	$alpha = $this->components['a'];	5✔
383	unset($componentsWithoutAlpha['a']);	5✔
384	}
385
386	$formatter = $outputFormat->getFormatter();	17✔
387	$arguments = $formatter->implode(' ', $componentsWithoutAlpha);	17✔
388	if (isset($alpha)) {	17✔
389	$separator = $formatter->spaceBeforeListArgumentSeparator('/')	5✔
390	. '/' . $formatter->spaceAfterListArgumentSeparator('/');	5✔
391	$arguments = $formatter->implode($separator, [$arguments, $alpha]);	5✔
392	}
393
394	return $this->getName() . '(' . $arguments . ')';	17✔
395	}
396	}

MyIntervals / PHP-CSS-Parser / 13888006503

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous