comparison vendor/symfony/validator/Validator/RecursiveContextualValidator.php @ 4:a9cd425dd02b

Update, including to Drupal core 8.6.10

  */
 
 namespace Symfony\Component\Validator\Validator;
 
 use Symfony\Component\Validator\Constraint;
+use Symfony\Component\Validator\Constraints\Composite;
 use Symfony\Component\Validator\Constraints\GroupSequence;
 use Symfony\Component\Validator\ConstraintValidatorFactoryInterface;
 use Symfony\Component\Validator\Context\ExecutionContext;
 use Symfony\Component\Validator\Context\ExecutionContextInterface;
 use Symfony\Component\Validator\Exception\ConstraintDefinitionException;

 use Symfony\Component\Validator\Exception\RuntimeException;
 use Symfony\Component\Validator\Exception\UnsupportedMetadataException;
 use Symfony\Component\Validator\Exception\ValidatorException;
 use Symfony\Component\Validator\Mapping\CascadingStrategy;
 use Symfony\Component\Validator\Mapping\ClassMetadataInterface;
+use Symfony\Component\Validator\Mapping\Factory\MetadataFactoryInterface;
 use Symfony\Component\Validator\Mapping\GenericMetadata;
 use Symfony\Component\Validator\Mapping\MetadataInterface;
 use Symfony\Component\Validator\Mapping\PropertyMetadataInterface;
 use Symfony\Component\Validator\Mapping\TraversalStrategy;
-use Symfony\Component\Validator\Mapping\Factory\MetadataFactoryInterface;
 use Symfony\Component\Validator\ObjectInitializerInterface;
 use Symfony\Component\Validator\Util\PropertyPath;
 
 /**
  * Recursive implementation of {@link ContextualValidatorInterface}.

      *                                                                of validated objects
      * @param ConstraintValidatorFactoryInterface $validatorFactory   The factory for creating
      *                                                                constraint validators
      * @param ObjectInitializerInterface[]        $objectInitializers The object initializers
      */
-    public function __construct(ExecutionContextInterface $context, MetadataFactoryInterface $metadataFactory, ConstraintValidatorFactoryInterface $validatorFactory, array $objectInitializers = array())
+    public function __construct(ExecutionContextInterface $context, MetadataFactoryInterface $metadataFactory, ConstraintValidatorFactoryInterface $validatorFactory, array $objectInitializers = [])
     {
         $this->context = $context;
         $this->defaultPropertyPath = $context->getPropertyPath();
-        $this->defaultGroups = array($context->getGroup() ?: Constraint::DEFAULT_GROUP);
+        $this->defaultGroups = [$context->getGroup() ?: Constraint::DEFAULT_GROUP];
         $this->metadataFactory = $metadataFactory;
         $this->validatorFactory = $validatorFactory;
         $this->objectInitializers = $objectInitializers;
     }
 

         // If explicit constraints are passed, validate the value against
         // those constraints
         if (null !== $constraints) {
             // You can pass a single constraint or an array of constraints
             // Make sure to deal with an array in the rest of the code
-            if (!is_array($constraints)) {
-                $constraints = array($constraints);
+            if (!\is_array($constraints)) {
+                $constraints = [$constraints];
             }
 
             $metadata = new GenericMetadata();
             $metadata->addConstraints($constraints);
 
             $this->validateGenericNode(
                 $value,
                 $previousObject,
-                is_object($value) ? spl_object_hash($value) : null,
+                \is_object($value) ? spl_object_hash($value) : null,
                 $metadata,
                 $this->defaultPropertyPath,
                 $groups,
                 null,
                 TraversalStrategy::IMPLICIT,

             return $this;
         }
 
         // If an object is passed without explicit constraints, validate that
         // object against the constraints defined for the object's class
-        if (is_object($value)) {
+        if (\is_object($value)) {
             $this->validateObject(
                 $value,
                 $this->defaultPropertyPath,
                 $groups,
                 TraversalStrategy::IMPLICIT,

             return $this;
         }
 
         // If an array is passed without explicit constraints, validate each
         // object in the array
-        if (is_array($value)) {
+        if (\is_array($value)) {
             $this->validateEachObjectIn(
                 $value,
                 $this->defaultPropertyPath,
                 $groups,
                 $this->context

             $this->context->setGroup($previousGroup);
 
             return $this;
         }
 
-        throw new RuntimeException(sprintf(
-            'Cannot validate values of type "%s" automatically. Please '.
-            'provide a constraint.',
-            gettype($value)
-        ));
+        throw new RuntimeException(sprintf('Cannot validate values of type "%s" automatically. Please provide a constraint.', \gettype($value)));
     }
 
     /**
      * {@inheritdoc}
      */
     public function validateProperty($object, $propertyName, $groups = null)
     {
         $classMetadata = $this->metadataFactory->getMetadataFor($object);
 
         if (!$classMetadata instanceof ClassMetadataInterface) {
-            throw new ValidatorException(sprintf(
-                'The metadata factory should return instances of '.
-                '"\Symfony\Component\Validator\Mapping\ClassMetadataInterface", '.
-                'got: "%s".',
-                is_object($classMetadata) ? get_class($classMetadata) : gettype($classMetadata)
-            ));
+            throw new ValidatorException(sprintf('The metadata factory should return instances of "\Symfony\Component\Validator\Mapping\ClassMetadataInterface", got: "%s".', \is_object($classMetadata) ? \get_class($classMetadata) : \gettype($classMetadata)));
         }
 
         $propertyMetadatas = $classMetadata->getPropertyMetadata($propertyName);
         $groups = $groups ? $this->normalizeGroups($groups) : $this->defaultGroups;
         $cacheKey = spl_object_hash($object);

             $propertyValue = $propertyMetadata->getPropertyValue($object);
 
             $this->validateGenericNode(
                 $propertyValue,
                 $object,
-                $cacheKey.':'.get_class($object).':'.$propertyName,
+                $cacheKey.':'.\get_class($object).':'.$propertyName,
                 $propertyMetadata,
                 $propertyPath,
                 $groups,
                 null,
                 TraversalStrategy::IMPLICIT,

     public function validatePropertyValue($objectOrClass, $propertyName, $value, $groups = null)
     {
         $classMetadata = $this->metadataFactory->getMetadataFor($objectOrClass);
 
         if (!$classMetadata instanceof ClassMetadataInterface) {
-            throw new ValidatorException(sprintf(
-                'The metadata factory should return instances of '.
-                '"\Symfony\Component\Validator\Mapping\ClassMetadataInterface", '.
-                'got: "%s".',
-                is_object($classMetadata) ? get_class($classMetadata) : gettype($classMetadata)
-            ));
+            throw new ValidatorException(sprintf('The metadata factory should return instances of "\Symfony\Component\Validator\Mapping\ClassMetadataInterface", got: "%s".', \is_object($classMetadata) ? \get_class($classMetadata) : \gettype($classMetadata)));
         }
 
         $propertyMetadatas = $classMetadata->getPropertyMetadata($propertyName);
         $groups = $groups ? $this->normalizeGroups($groups) : $this->defaultGroups;
 
-        if (is_object($objectOrClass)) {
+        if (\is_object($objectOrClass)) {
             $object = $objectOrClass;
-            $class = get_class($object);
+            $class = \get_class($object);
             $cacheKey = spl_object_hash($objectOrClass);
             $propertyPath = PropertyPath::append($this->defaultPropertyPath, $propertyName);
         } else {
             // $objectOrClass contains a class name
             $object = null;

     }
 
     /**
      * Normalizes the given group or list of groups to an array.
      *
-     * @param mixed $groups The groups to normalize
-     *
-     * @return array A group array
+     * @param string|GroupSequence|(string|GroupSequence)[] $groups The groups to normalize
+     *
+     * @return (string|GroupSequence)[] A group array
      */
     protected function normalizeGroups($groups)
     {
-        if (is_array($groups)) {
+        if (\is_array($groups)) {
             return $groups;
         }
 
-        return array($groups);
+        return [$groups];
     }
 
     /**
      * Validates an object against the constraints defined for its class.
      *

      * traversal, the object will be iterated and each nested object will be
      * validated instead.
      *
      * @param object                    $object            The object to cascade
      * @param string                    $propertyPath      The current property path
-     * @param string[]                  $groups            The validated groups
+     * @param (string|GroupSequence)[]  $groups            The validated groups
      * @param int                       $traversalStrategy The strategy for traversing the
      *                                                     cascaded object
      * @param ExecutionContextInterface $context           The current execution context
      *
      * @throws NoSuchMetadataException      If the object has no associated metadata

     {
         try {
             $classMetadata = $this->metadataFactory->getMetadataFor($object);
 
             if (!$classMetadata instanceof ClassMetadataInterface) {
-                throw new UnsupportedMetadataException(sprintf(
-                    'The metadata factory should return instances of '.
-                    '"Symfony\Component\Validator\Mapping\ClassMetadataInterface", '.
-                    'got: "%s".',
-                    is_object($classMetadata) ? get_class($classMetadata) : gettype($classMetadata)
-                ));
+                throw new UnsupportedMetadataException(sprintf('The metadata factory should return instances of "Symfony\Component\Validator\Mapping\ClassMetadataInterface", got: "%s".', \is_object($classMetadata) ? \get_class($classMetadata) : \gettype($classMetadata)));
             }
 
             $this->validateClassNode(
                 $object,
                 spl_object_hash($object),

      * objects are iterated as well. Nested arrays are always iterated,
      * regardless of the value of $recursive.
      *
      * @param iterable                  $collection   The collection
      * @param string                    $propertyPath The current property path
-     * @param string[]                  $groups       The validated groups
+     * @param (string|GroupSequence)[]  $groups       The validated groups
      * @param ExecutionContextInterface $context      The current execution context
      *
      * @see ClassNode
      * @see CollectionNode
      */
     private function validateEachObjectIn($collection, $propertyPath, array $groups, ExecutionContextInterface $context)
     {
         foreach ($collection as $key => $value) {
-            if (is_array($value)) {
+            if (\is_array($value)) {
                 // Arrays are always cascaded, independent of the specified
                 // traversal strategy
                 $this->validateEachObjectIn(
                     $value,
                     $propertyPath.'['.$key.']',

 
                 continue;
             }
 
             // Scalar and null values in the collection are ignored
-            if (is_object($value)) {
+            if (\is_object($value)) {
                 $this->validateObject(
                     $value,
                     $propertyPath.'['.$key.']',
                     $groups,
                     TraversalStrategy::IMPLICIT,

      *                                                     the validated object
      * @param ClassMetadataInterface    $metadata          The class metadata of
      *                                                     the object
      * @param string                    $propertyPath      The property path leading
      *                                                     to the object
-     * @param string[]                  $groups            The groups in which the
+     * @param (string|GroupSequence)[]  $groups            The groups in which the
      *                                                     object should be validated
      * @param string[]|null             $cascadedGroups    The groups in which
      *                                                     cascaded objects should
      *                                                     be validated
      * @param int                       $traversalStrategy The strategy used for

             // to cascade the "Default" group when traversing the group
             // sequence
             $defaultOverridden = false;
 
             // Use the object hash for group sequences
-            $groupHash = is_object($group) ? spl_object_hash($group) : $group;
+            $groupHash = \is_object($group) ? spl_object_hash($group) : $group;
 
             if ($context->isGroupValidated($cacheKey, $groupHash)) {
                 // Skip this group when validating the properties and when
                 // traversing the object
                 unset($groups[$key]);

             $this->validateInGroup($object, $cacheKey, $metadata, $group, $context);
         }
 
         // If no more groups should be validated for the property nodes,
         // we can safely quit
-        if (0 === count($groups)) {
+        if (0 === \count($groups)) {
             return;
         }
 
         // Validate all properties against their constraints
         foreach ($metadata->getConstrainedProperties() as $propertyName) {
             // If constraints are defined both on the getter of a property as
             // well as on the property itself, then getPropertyMetadata()
             // returns two metadata objects, not just one
             foreach ($metadata->getPropertyMetadata($propertyName) as $propertyMetadata) {
                 if (!$propertyMetadata instanceof PropertyMetadataInterface) {
-                    throw new UnsupportedMetadataException(sprintf(
-                        'The property metadata instances should implement '.
-                        '"Symfony\Component\Validator\Mapping\PropertyMetadataInterface", '.
-                        'got: "%s".',
-                        is_object($propertyMetadata) ? get_class($propertyMetadata) : gettype($propertyMetadata)
-                    ));
+                    throw new UnsupportedMetadataException(sprintf('The property metadata instances should implement "Symfony\Component\Validator\Mapping\PropertyMetadataInterface", got: "%s".', \is_object($propertyMetadata) ? \get_class($propertyMetadata) : \gettype($propertyMetadata)));
                 }
 
                 $propertyValue = $propertyMetadata->getPropertyValue($object);
 
                 $this->validateGenericNode(
                     $propertyValue,
                     $object,
-                    $cacheKey.':'.get_class($object).':'.$propertyName,
+                    $cacheKey.':'.\get_class($object).':'.$propertyName,
                     $propertyMetadata,
                     PropertyPath::append($propertyPath, $propertyName),
                     $groups,
                     $cascadedGroups,
                     TraversalStrategy::IMPLICIT,

             return;
         }
 
         // If TRAVERSE, fail if we have no Traversable
         if (!$object instanceof \Traversable) {
-            throw new ConstraintDefinitionException(sprintf(
-                'Traversal was enabled for "%s", but this class '.
-                'does not implement "\Traversable".',
-                get_class($object)
-            ));
+            throw new ConstraintDefinitionException(sprintf('Traversal was enabled for "%s", but this class does not implement "\Traversable".', \get_class($object)));
         }
 
         $this->validateEachObjectIn(
             $object,
             $propertyPath,

      *                                                     the validated value
      * @param MetadataInterface         $metadata          The metadata of the
      *                                                     value
      * @param string                    $propertyPath      The property path leading
      *                                                     to the value
-     * @param string[]                  $groups            The groups in which the
+     * @param (string|GroupSequence)[]  $groups            The groups in which the
      *                                                     value should be validated
      * @param string[]|null             $cascadedGroups    The groups in which
      *                                                     cascaded objects should
      *                                                     be validated
      * @param int                       $traversalStrategy The strategy used for

             }
 
             $this->validateInGroup($value, $cacheKey, $metadata, $group, $context);
         }
 
-        if (0 === count($groups)) {
+        if (0 === \count($groups)) {
             return;
         }
 
         if (null === $value) {
             return;
         }
 
         $cascadingStrategy = $metadata->getCascadingStrategy();
 
         // Quit unless we have an array or a cascaded object
-        if (!is_array($value) && !($cascadingStrategy & CascadingStrategy::CASCADE)) {
+        if (!\is_array($value) && !($cascadingStrategy & CascadingStrategy::CASCADE)) {
             return;
         }
 
         // If no specific traversal strategy was requested when this method
         // was called, use the traversal strategy of the node's metadata

         }
 
         // The $cascadedGroups property is set, if the "Default" group is
         // overridden by a group sequence
         // See validateClassNode()
-        $cascadedGroups = null !== $cascadedGroups && count($cascadedGroups) > 0 ? $cascadedGroups : $groups;
-
-        if (is_array($value)) {
+        $cascadedGroups = null !== $cascadedGroups && \count($cascadedGroups) > 0 ? $cascadedGroups : $groups;
+
+        if (\is_array($value)) {
             // Arrays are always traversed, independent of the specified
             // traversal strategy
             $this->validateEachObjectIn(
                 $value,
                 $propertyPath,

      *                                                     the group sequence
      * @param ExecutionContextInterface $context           The execution context
      */
     private function stepThroughGroupSequence($value, $object, $cacheKey, MetadataInterface $metadata = null, $propertyPath, $traversalStrategy, GroupSequence $groupSequence, $cascadedGroup, ExecutionContextInterface $context)
     {
-        $violationCount = count($context->getViolations());
-        $cascadedGroups = $cascadedGroup ? array($cascadedGroup) : null;
+        $violationCount = \count($context->getViolations());
+        $cascadedGroups = $cascadedGroup ? [$cascadedGroup] : null;
 
         foreach ($groupSequence->groups as $groupInSequence) {
             $groups = (array) $groupInSequence;
 
             if ($metadata instanceof ClassMetadataInterface) {

                      $context
                 );
             }
 
             // Abort sequence validation if a violation was generated
-            if (count($context->getViolations()) > $violationCount) {
+            if (\count($context->getViolations()) > $violationCount) {
                 break;
             }
         }
     }
 

             // Prevent duplicate validation of constraints, in the case
             // that constraints belong to multiple validated groups
             if (null !== $cacheKey) {
                 $constraintHash = spl_object_hash($constraint);
 
+                if ($constraint instanceof Composite) {
+                    $constraintHash .= $group;
+                }
+
                 if ($context->isConstraintValidated($cacheKey, $constraintHash)) {
                     continue;
                 }
 
                 $context->markConstraintAsValidated($cacheKey, $constraintHash);