ValidatorPropertyMetadataFactory::getValidationGroups() - Code Metrics - Inspection of "Merge pull request #3329 from penja/property_shema..." - api-platform/core - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 799d88...dee4c0 )

by Antoine

created 2020-02-18 15:02 UTC

getValidationGroups() A

↳ Parent: ValidatorPropertyMetadataFactory

Complexity

Conditions	3
Paths	3

Size

Total Lines	11
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
eloc	5
c	0
b	0
f	0
nc	3
nop	2
dl	0
loc	11
rs	10

<?php

/*
 * This file is part of the API Platform project.
 *
 * (c) Kévin Dunglas <[email protected]>
 *
 * 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\Core\Bridge\Symfony\Validator\Metadata\Property;

use ApiPlatform\Core\Bridge\Symfony\Validator\Metadata\Property\Restriction\PropertySchemaRestrictionMetadataInterface;
use ApiPlatform\Core\Metadata\Property\Factory\PropertyMetadataFactoryInterface;
use ApiPlatform\Core\Metadata\Property\PropertyMetadata;
use Symfony\Component\Validator\Constraint;
use Symfony\Component\Validator\Constraints\Bic;
use Symfony\Component\Validator\Constraints\CardScheme;
use Symfony\Component\Validator\Constraints\Currency;
use Symfony\Component\Validator\Constraints\Date;
use Symfony\Component\Validator\Constraints\DateTime;
use Symfony\Component\Validator\Constraints\Email;
use Symfony\Component\Validator\Constraints\File;
use Symfony\Component\Validator\Constraints\Iban;
use Symfony\Component\Validator\Constraints\Image;
use Symfony\Component\Validator\Constraints\Isbn;
use Symfony\Component\Validator\Constraints\Issn;
use Symfony\Component\Validator\Constraints\NotBlank;
use Symfony\Component\Validator\Constraints\NotNull;
use Symfony\Component\Validator\Constraints\Time;
use Symfony\Component\Validator\Constraints\Url;
use Symfony\Component\Validator\Constraints\Uuid;
use Symfony\Component\Validator\Mapping\ClassMetadataInterface as ValidatorClassMetadataInterface;
use Symfony\Component\Validator\Mapping\Factory\MetadataFactoryInterface as ValidatorMetadataFactoryInterface;
use Symfony\Component\Validator\Mapping\PropertyMetadataInterface as ValidatorPropertyMetadataInterface;

/**
 * Decorates a metadata loader using the validator.
 *
 * @author Kévin Dunglas <[email protected]>
 */
final class ValidatorPropertyMetadataFactory implements PropertyMetadataFactoryInterface
{
    /**
     * @var string[] A list of constraint classes making the entity required
     */
    public const REQUIRED_CONSTRAINTS = [NotBlank::class, NotNull::class];

    public const SCHEMA_MAPPED_CONSTRAINTS = [
        Url::class => 'http://schema.org/url',
        Email::class => 'http://schema.org/email',
        Uuid::class => 'http://schema.org/identifier',
        CardScheme::class => 'http://schema.org/identifier',
        Bic::class => 'http://schema.org/identifier',
        Iban::class => 'http://schema.org/identifier',
        Date::class => 'http://schema.org/Date',
        DateTime::class => 'http://schema.org/DateTime',
        Time::class => 'http://schema.org/Time',
        Image::class => 'http://schema.org/image',
        File::class => 'http://schema.org/MediaObject',
        Currency::class => 'http://schema.org/priceCurrency',
        Isbn::class => 'http://schema.org/isbn',
        Issn::class => 'http://schema.org/issn',
    ];

    private $decorated;
    private $validatorMetadataFactory;
    /**
     * @var iterable<PropertySchemaRestrictionMetadataInterface>
     */
    private $restrictionsMetadata;

    /**
     * @param PropertySchemaRestrictionMetadataInterface[] $restrictionsMetadata
     */
    public function __construct(ValidatorMetadataFactoryInterface $validatorMetadataFactory, PropertyMetadataFactoryInterface $decorated, iterable $restrictionsMetadata = [])
    {
        $this->validatorMetadataFactory = $validatorMetadataFactory;
        $this->decorated = $decorated;
        $this->restrictionsMetadata = $restrictionsMetadata;
    }

    /**
     * {@inheritdoc}
     */
    public function create(string $resourceClass, string $name, array $options = []): PropertyMetadata
    {
        $propertyMetadata = $this->decorated->create($resourceClass, $name, $options);

        $required = $propertyMetadata->isRequired();
        $iri = $propertyMetadata->getIri();
        $schema = $propertyMetadata->getSchema();

        if (null !== $required && null !== $iri && null !== $schema) {
            return $propertyMetadata;
        }

        $validatorClassMetadata = $this->validatorMetadataFactory->getMetadataFor($resourceClass);

        if (!$validatorClassMetadata instanceof ValidatorClassMetadataInterface) {
            throw new \UnexpectedValueException(sprintf('Validator class metadata expected to be of type "%s".', ValidatorClassMetadataInterface::class));
        }

        $validationGroups = $this->getValidationGroups($validatorClassMetadata, $options);
        $restrictions = [];

        foreach ($validatorClassMetadata->getPropertyMetadata($name) as $validatorPropertyMetadata) {
            foreach ($this->getPropertyConstraints($validatorPropertyMetadata, $validationGroups) as $constraint) {
                if (null === $required && $this->isRequired($constraint)) {
                    $required = true;
                }

                if (null === $iri) {
                    $iri = self::SCHEMA_MAPPED_CONSTRAINTS[\get_class($constraint)] ?? null;
                }

                foreach ($this->restrictionsMetadata as $restrictionMetadata) {
                    if ($restrictionMetadata->supports($constraint, $propertyMetadata)) {
                        $restrictions[] = $restrictionMetadata->create($constraint, $propertyMetadata);
                    }
                }
            }
        }

        $propertyMetadata = $propertyMetadata->withIri($iri)->withRequired($required ?? false);

        if (!empty($restrictions)) {
            if (null === $schema) {
                $schema = [];
            }

            $schema += array_merge(...$restrictions);
            $propertyMetadata = $propertyMetadata->withSchema($schema);
        }

        return $propertyMetadata;
    }

    /**
     * Returns the list of validation groups.
     */
    private function getValidationGroups(ValidatorClassMetadataInterface $classMetadata, array $options): array
    {
        if (isset($options['validation_groups'])) {
            return $options['validation_groups'];
        }

        if (!method_exists($classMetadata, 'getDefaultGroup')) {
            throw new \UnexpectedValueException(sprintf('Validator class metadata expected to have method "%s".', 'getDefaultGroup'));
        }

        return [$classMetadata->getDefaultGroup()];
    }

    /**
     * Tests if the property is required because of its validation groups.
     */
    private function getPropertyConstraints(
        ValidatorPropertyMetadataInterface $validatorPropertyMetadata,
        array $groups
    ): array {
        $constraints = [];

        foreach ($groups as $validationGroup) {
            if (!\is_string($validationGroup)) {
                continue;
            }

            foreach ($validatorPropertyMetadata->findConstraints($validationGroup) as $propertyConstraint) {
                $constraints[] = $propertyConstraint;
            }
        }

        return $constraints;
    }

    /**
     * Is this constraint making the related property required?
     */
    private function isRequired(Constraint $constraint): bool
    {
        foreach (self::REQUIRED_CONSTRAINTS as $requiredConstraint) {
            if ($constraint instanceof $requiredConstraint) {
                return true;
            }
        }

        return false;
    }
}


1			<?php
2
3			/*
4			* This file is part of the API Platform project.
5			*
6			* (c) Kévin Dunglas <[email protected]>
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\Core\Bridge\Symfony\Validator\Metadata\Property;
15
16			use ApiPlatform\Core\Bridge\Symfony\Validator\Metadata\Property\Restriction\PropertySchemaRestrictionMetadataInterface;
17			use ApiPlatform\Core\Metadata\Property\Factory\PropertyMetadataFactoryInterface;
18			use ApiPlatform\Core\Metadata\Property\PropertyMetadata;
19			use Symfony\Component\Validator\Constraint;
20			use Symfony\Component\Validator\Constraints\Bic;
21			use Symfony\Component\Validator\Constraints\CardScheme;
22			use Symfony\Component\Validator\Constraints\Currency;
23			use Symfony\Component\Validator\Constraints\Date;
24			use Symfony\Component\Validator\Constraints\DateTime;
25			use Symfony\Component\Validator\Constraints\Email;
26			use Symfony\Component\Validator\Constraints\File;
27			use Symfony\Component\Validator\Constraints\Iban;
28			use Symfony\Component\Validator\Constraints\Image;
29			use Symfony\Component\Validator\Constraints\Isbn;
30			use Symfony\Component\Validator\Constraints\Issn;
31			use Symfony\Component\Validator\Constraints\NotBlank;
32			use Symfony\Component\Validator\Constraints\NotNull;
33			use Symfony\Component\Validator\Constraints\Time;
34			use Symfony\Component\Validator\Constraints\Url;
35			use Symfony\Component\Validator\Constraints\Uuid;
36			use Symfony\Component\Validator\Mapping\ClassMetadataInterface as ValidatorClassMetadataInterface;
37			use Symfony\Component\Validator\Mapping\Factory\MetadataFactoryInterface as ValidatorMetadataFactoryInterface;
38			use Symfony\Component\Validator\Mapping\PropertyMetadataInterface as ValidatorPropertyMetadataInterface;
39
40			/**
41			* Decorates a metadata loader using the validator.
42			*
43			* @author Kévin Dunglas <[email protected]>
44			*/
45			final class ValidatorPropertyMetadataFactory implements PropertyMetadataFactoryInterface
46			{
47			/**
48			* @var string[] A list of constraint classes making the entity required
49			*/
50			public const REQUIRED_CONSTRAINTS = [NotBlank::class, NotNull::class];
51
52			public const SCHEMA_MAPPED_CONSTRAINTS = [
53			Url::class => 'http://schema.org/url',
54			Email::class => 'http://schema.org/email',
55			Uuid::class => 'http://schema.org/identifier',
56			CardScheme::class => 'http://schema.org/identifier',
57			Bic::class => 'http://schema.org/identifier',
58			Iban::class => 'http://schema.org/identifier',
59			Date::class => 'http://schema.org/Date',
60			DateTime::class => 'http://schema.org/DateTime',
61			Time::class => 'http://schema.org/Time',
62			Image::class => 'http://schema.org/image',
63			File::class => 'http://schema.org/MediaObject',
64			Currency::class => 'http://schema.org/priceCurrency',
65			Isbn::class => 'http://schema.org/isbn',
66			Issn::class => 'http://schema.org/issn',
67			];
68
69			private $decorated;
70			private $validatorMetadataFactory;
71			/**
72			* @var iterable<PropertySchemaRestrictionMetadataInterface>
73			*/
74			private $restrictionsMetadata;
75
76			/**
77			* @param PropertySchemaRestrictionMetadataInterface[] $restrictionsMetadata
78			*/
79			public function __construct(ValidatorMetadataFactoryInterface $validatorMetadataFactory, PropertyMetadataFactoryInterface $decorated, iterable $restrictionsMetadata = [])
80			{
81			$this->validatorMetadataFactory = $validatorMetadataFactory;
82			$this->decorated = $decorated;
83			$this->restrictionsMetadata = $restrictionsMetadata;
84			}
85
86			/**
87			* {@inheritdoc}
88			*/
89			public function create(string $resourceClass, string $name, array $options = []): PropertyMetadata
90			{
91			$propertyMetadata = $this->decorated->create($resourceClass, $name, $options);
92
93			$required = $propertyMetadata->isRequired();
94			$iri = $propertyMetadata->getIri();
95			$schema = $propertyMetadata->getSchema();
96
97			if (null !== $required && null !== $iri && null !== $schema) {
98			return $propertyMetadata;
99			}
100
101			$validatorClassMetadata = $this->validatorMetadataFactory->getMetadataFor($resourceClass);
102
103			if (!$validatorClassMetadata instanceof ValidatorClassMetadataInterface) {
104			throw new \UnexpectedValueException(sprintf('Validator class metadata expected to be of type "%s".', ValidatorClassMetadataInterface::class));
105			}
106
107			$validationGroups = $this->getValidationGroups($validatorClassMetadata, $options);
108			$restrictions = [];
109
110			foreach ($validatorClassMetadata->getPropertyMetadata($name) as $validatorPropertyMetadata) {
111			foreach ($this->getPropertyConstraints($validatorPropertyMetadata, $validationGroups) as $constraint) {
112			if (null === $required && $this->isRequired($constraint)) {
113			$required = true;
114			}
115
116			if (null === $iri) {
117			$iri = self::SCHEMA_MAPPED_CONSTRAINTS[\get_class($constraint)] ?? null;
118			}
119
120			foreach ($this->restrictionsMetadata as $restrictionMetadata) {
121			if ($restrictionMetadata->supports($constraint, $propertyMetadata)) {
122			$restrictions[] = $restrictionMetadata->create($constraint, $propertyMetadata);
123			}
124			}
125			}
126			}
127
128			$propertyMetadata = $propertyMetadata->withIri($iri)->withRequired($required ?? false);
129
130			if (!empty($restrictions)) {
131			if (null === $schema) {
132			$schema = [];
133			}
134
135			$schema += array_merge(...$restrictions);
136			$propertyMetadata = $propertyMetadata->withSchema($schema);
137			}
138
139			return $propertyMetadata;
140			}
141
142			/**
143			* Returns the list of validation groups.
144			*/
145			private function getValidationGroups(ValidatorClassMetadataInterface $classMetadata, array $options): array
146			{
147			if (isset($options['validation_groups'])) {
148			return $options['validation_groups'];
149			}
150
151			if (!method_exists($classMetadata, 'getDefaultGroup')) {
152			throw new \UnexpectedValueException(sprintf('Validator class metadata expected to have method "%s".', 'getDefaultGroup'));
153			}
154
155			return [$classMetadata->getDefaultGroup()];
156			}
157
158			/**
159			* Tests if the property is required because of its validation groups.
160			*/
161			private function getPropertyConstraints(
162			ValidatorPropertyMetadataInterface $validatorPropertyMetadata,
163			array $groups
164			): array {
165			$constraints = [];
166
167			foreach ($groups as $validationGroup) {
168			if (!\is_string($validationGroup)) {
169			continue;
170			}
171
172			foreach ($validatorPropertyMetadata->findConstraints($validationGroup) as $propertyConstraint) {
173			$constraints[] = $propertyConstraint;
174			}
175			}
176
177			return $constraints;
178			}
179
180			/**
181			* Is this constraint making the related property required?
182			*/
183			private function isRequired(Constraint $constraint): bool
184			{
185			foreach (self::REQUIRED_CONSTRAINTS as $requiredConstraint) {
186			if ($constraint instanceof $requiredConstraint) {
187			return true;
188			}
189			}
190
191			return false;
192			}
193			}
194

api-platform / core

Push — master ( 799d88...dee4c0 )

getValidationGroups() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like