15255731762

Committed 26 May 2025 01:55PM UTC coverage: 0.0% (-26.5%) from 26.526%

Build # 15255731762

Build Type

Pull #7176

github

Committed by

web-flow

Commit Message

Merge 66f6cf4d2 into 79edced67

Pull Request Pull Request #7176: Merge 4.1

Run Details

0 of 387 new or added lines in 28 files covered. (0.0%)

11394 existing lines in 372 files now uncovered.

0 of 51334 relevant lines covered (0.0%)

0.0 hits per line

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

0.0

/src/Symfony/Validator/Metadata/Property/Restriction/PropertySchemaChoiceRestriction.php

<?php

/*
 * This file is part of the API Platform project.
 *
 * (c) Kévin Dunglas <dunglas@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace ApiPlatform\Symfony\Validator\Metadata\Property\Restriction;

use ApiPlatform\Metadata\ApiProperty;
use ApiPlatform\Metadata\Util\TypeHelper;
use Symfony\Component\PropertyInfo\PropertyInfoExtractor;
use Symfony\Component\PropertyInfo\Type as LegacyType;
use Symfony\Component\TypeInfo\Type;
use Symfony\Component\TypeInfo\Type\CollectionType;
use Symfony\Component\TypeInfo\TypeIdentifier;
use Symfony\Component\Validator\Constraint;
use Symfony\Component\Validator\Constraints\Choice;

/**
 * @author Tomas Norkūnas <norkunas.tom@gmail.com>
 */
final class PropertySchemaChoiceRestriction implements PropertySchemaRestrictionMetadataInterface
{
    /**
     * {@inheritdoc}
     *
     * @param Choice $constraint
     */
    public function create(Constraint $constraint, ApiProperty $propertyMetadata): array
    {
        $choices = [];

        if (\is_callable($constraint->callback)) {
            $choices = ($constraint->callback)();
        } elseif (\is_array($constraint->choices)) {
            $choices = $constraint->choices;
        }

        if (!$choices) {
            return [];
        }

        $restriction = [];

        if (!$constraint->multiple) {
            $restriction['enum'] = $choices;

            return $restriction;
        }

        $restriction['type'] = 'array';

        $types = array_values(array_unique(array_map(fn (mixed $choice) => \is_string($choice) ? 'string' : 'number', $choices)));

        if ($count = \count($types)) {
            if (1 === $count) {
                $types = $types[0];
            }

            $restriction['items'] = ['type' => $types, 'enum' => $choices];
        }

        if (null !== $constraint->min) {
            $restriction['minItems'] = $constraint->min;
        }

        if (null !== $constraint->max) {
            $restriction['maxItems'] = $constraint->max;
        }

        return $restriction;
    }

    public function supports(Constraint $constraint, ApiProperty $propertyMetadata): bool
    {
        if (!$constraint instanceof Choice) {
            return false;
        }

        if (method_exists(PropertyInfoExtractor::class, 'getType')) {
            $nativeType = $propertyMetadata->getExtraProperties()['nested_schema'] ?? false
                ? Type::string()
                : $propertyMetadata->getNativeType();

            $isValidScalarType = fn (Type $t): bool => $t->isSatisfiedBy(
                fn (Type $subType): bool => $subType->isIdentifiedBy(TypeIdentifier::STRING, TypeIdentifier::INT, TypeIdentifier::FLOAT)
            );

            if ($isValidScalarType($nativeType)) {
                return true;
            }

            if ($nativeType->isSatisfiedBy(fn ($t) => $t instanceof CollectionType)) {
                if (null !== ($collectionValueType = TypeHelper::getCollectionValueType($nativeType)) && $isValidScalarType($collectionValueType)) {
                    return true;
                }
            }

            return false;
        }

        $types = array_map(static fn (LegacyType $type) => $type->getBuiltinType(), $propertyMetadata->getBuiltinTypes() ?? []);
        if ($propertyMetadata->getExtraProperties()['nested_schema'] ?? false) {
            $types = [LegacyType::BUILTIN_TYPE_STRING];
        }

        if (
            null !== ($builtinType = ($propertyMetadata->getBuiltinTypes()[0] ?? null))
            && $builtinType->isCollection()
            && \count($builtinType->getCollectionValueTypes()) > 0
        ) {
            $types = array_unique(array_merge($types, array_map(static fn (LegacyType $type) => $type->getBuiltinType(), $builtinType->getCollectionValueTypes())));
        }

        return \count($types) > 0 && \count(array_intersect($types, [LegacyType::BUILTIN_TYPE_STRING, LegacyType::BUILTIN_TYPE_INT, LegacyType::BUILTIN_TYPE_FLOAT])) > 0;
    }
}

1	<?php
2
3	/*
4	* This file is part of the API Platform project.
5	*
6	* (c) Kévin Dunglas <dunglas@gmail.com>
7	*
8	* For the full copyright and license information, please view the LICENSE
9	* file that was distributed with this source code.
10	*/
11
12	declare(strict_types=1);
13
14	namespace ApiPlatform\Symfony\Validator\Metadata\Property\Restriction;
15
16	use ApiPlatform\Metadata\ApiProperty;
17	use ApiPlatform\Metadata\Util\TypeHelper;
18	use Symfony\Component\PropertyInfo\PropertyInfoExtractor;
19	use Symfony\Component\PropertyInfo\Type as LegacyType;
20	use Symfony\Component\TypeInfo\Type;
21	use Symfony\Component\TypeInfo\Type\CollectionType;
22	use Symfony\Component\TypeInfo\TypeIdentifier;
23	use Symfony\Component\Validator\Constraint;
24	use Symfony\Component\Validator\Constraints\Choice;
25
26	/**
27	* @author Tomas Norkūnas <norkunas.tom@gmail.com>
28	*/
29	final class PropertySchemaChoiceRestriction implements PropertySchemaRestrictionMetadataInterface
30	{
31	/**
32	* {@inheritdoc}
33	*
34	* @param Choice $constraint
35	*/
36	public function create(Constraint $constraint, ApiProperty $propertyMetadata): array
37	{
38	$choices = [];	×
39
40	if (\is_callable($constraint->callback)) {	×
41	$choices = ($constraint->callback)();	×
42	} elseif (\is_array($constraint->choices)) {	×
43	$choices = $constraint->choices;	×
44	}
45
46	if (!$choices) {	×
47	return [];	×
48	}
49
50	$restriction = [];	×
51
52	if (!$constraint->multiple) {	×
53	$restriction['enum'] = $choices;	×
54
55	return $restriction;	×
56	}
57
58	$restriction['type'] = 'array';	×
59
60	$types = array_values(array_unique(array_map(fn (mixed $choice) => \is_string($choice) ? 'string' : 'number', $choices)));	×
61
62	if ($count = \count($types)) {	×
63	if (1 === $count) {	×
64	$types = $types[0];	×
65	}
66
67	$restriction['items'] = ['type' => $types, 'enum' => $choices];	×
68	}
69
70	if (null !== $constraint->min) {	×
71	$restriction['minItems'] = $constraint->min;	×
72	}
73
74	if (null !== $constraint->max) {	×
75	$restriction['maxItems'] = $constraint->max;	×
76	}
77
78	return $restriction;	×
79	}
80
81	public function supports(Constraint $constraint, ApiProperty $propertyMetadata): bool
82	{
UNCOV 83	if (!$constraint instanceof Choice) {	×
UNCOV 84	return false;	×
85	}
86
87	if (method_exists(PropertyInfoExtractor::class, 'getType')) {	×
88	$nativeType = $propertyMetadata->getExtraProperties()['nested_schema'] ?? false	×
89	? Type::string()	×
90	: $propertyMetadata->getNativeType();	×
91
92	$isValidScalarType = fn (Type $t): bool => $t->isSatisfiedBy(	×
93	fn (Type $subType): bool => $subType->isIdentifiedBy(TypeIdentifier::STRING, TypeIdentifier::INT, TypeIdentifier::FLOAT)	×
94	);	×
95
96	if ($isValidScalarType($nativeType)) {	×
97	return true;	×
98	}
99
100	if ($nativeType->isSatisfiedBy(fn ($t) => $t instanceof CollectionType)) {	×
101	if (null !== ($collectionValueType = TypeHelper::getCollectionValueType($nativeType)) && $isValidScalarType($collectionValueType)) {	×
102	return true;	×
103	}
104	}
105
106	return false;	×
107	}
108
109	$types = array_map(static fn (LegacyType $type) => $type->getBuiltinType(), $propertyMetadata->getBuiltinTypes() ?? []);	×
110	if ($propertyMetadata->getExtraProperties()['nested_schema'] ?? false) {	×
111	$types = [LegacyType::BUILTIN_TYPE_STRING];	×
112	}
113
114	if (
115	null !== ($builtinType = ($propertyMetadata->getBuiltinTypes()[0] ?? null))	×
116	&& $builtinType->isCollection()	×
117	&& \count($builtinType->getCollectionValueTypes()) > 0	×
118	) {
119	$types = array_unique(array_merge($types, array_map(static fn (LegacyType $type) => $type->getBuiltinType(), $builtinType->getCollectionValueTypes())));	×
120	}
121
122	return \count($types) > 0 && \count(array_intersect($types, [LegacyType::BUILTIN_TYPE_STRING, LegacyType::BUILTIN_TYPE_INT, LegacyType::BUILTIN_TYPE_FLOAT])) > 0;	×
123	}
124	}

api-platform / core / 15255731762

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