Move into nested docroot

This commit is contained in:
Rob Davies 2017-02-13 15:31:17 +00:00
parent 83a0d3a149
commit c8b70abde9
13405 changed files with 0 additions and 0 deletions

View file

@ -0,0 +1,88 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Validator\Validator;
use Symfony\Component\Validator\Constraint;
use Symfony\Component\Validator\ConstraintViolationListInterface;
/**
* A validator in a specific execution context.
*
* @author Bernhard Schussek <bschussek@gmail.com>
*/
interface ContextualValidatorInterface
{
/**
* Appends the given path to the property path of the context.
*
* If called multiple times, the path will always be reset to the context's
* original path with the given path appended to it.
*
* @param string $path The path to append
*
* @return $this
*/
public function atPath($path);
/**
* Validates a value against a constraint or a list of constraints.
*
* If no constraint is passed, the constraint
* {@link \Symfony\Component\Validator\Constraints\Valid} is assumed.
*
* @param mixed $value The value to validate
* @param Constraint|Constraint[] $constraints The constraint(s) to validate
* against
* @param array|null $groups The validation groups to
* validate. If none is given,
* "Default" is assumed
*
* @return $this
*/
public function validate($value, $constraints = null, $groups = null);
/**
* Validates a property of an object against the constraints specified
* for this property.
*
* @param object $object The object
* @param string $propertyName The name of the validated property
* @param array|null $groups The validation groups to validate. If
* none is given, "Default" is assumed
*
* @return $this
*/
public function validateProperty($object, $propertyName, $groups = null);
/**
* Validates a value against the constraints specified for an object's
* property.
*
* @param object|string $objectOrClass The object or its class name
* @param string $propertyName The name of the property
* @param mixed $value The value to validate against the
* property's constraints
* @param array|null $groups The validation groups to validate. If
* none is given, "Default" is assumed
*
* @return $this
*/
public function validatePropertyValue($objectOrClass, $propertyName, $value, $groups = null);
/**
* Returns the violations that have been generated so far in the context
* of the validator.
*
* @return ConstraintViolationListInterface The constraint violations
*/
public function getViolations();
}

View file

@ -0,0 +1,27 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Validator\Validator;
@trigger_error('The '.__NAMESPACE__.'\LegacyValidator class is deprecated since version 2.5 and will be removed in 3.0.', E_USER_DEPRECATED);
/**
* A validator that supports both the API of Symfony < 2.5 and Symfony 2.5+.
*
* @author Bernhard Schussek <bschussek@gmail.com>
*
* @see \Symfony\Component\Validator\ValidatorInterface
* @see \Symfony\Component\Validator\Validator\ValidatorInterface
* @deprecated since version 2.5, to be removed in 3.0.
*/
class LegacyValidator extends RecursiveValidator
{
}

View file

@ -0,0 +1,882 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Validator\Validator;
use Symfony\Component\Validator\Constraint;
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\NoSuchMetadataException;
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\GenericMetadata;
use Symfony\Component\Validator\Mapping\MetadataInterface;
use Symfony\Component\Validator\Mapping\PropertyMetadataInterface;
use Symfony\Component\Validator\Mapping\TraversalStrategy;
use Symfony\Component\Validator\MetadataFactoryInterface;
use Symfony\Component\Validator\ObjectInitializerInterface;
use Symfony\Component\Validator\Util\PropertyPath;
/**
* Recursive implementation of {@link ContextualValidatorInterface}.
*
* @author Bernhard Schussek <bschussek@gmail.com>
*/
class RecursiveContextualValidator implements ContextualValidatorInterface
{
/**
* @var ExecutionContextInterface
*/
private $context;
/**
* @var string
*/
private $defaultPropertyPath;
/**
* @var array
*/
private $defaultGroups;
/**
* @var MetadataFactoryInterface
*/
private $metadataFactory;
/**
* @var ConstraintValidatorFactoryInterface
*/
private $validatorFactory;
/**
* @var ObjectInitializerInterface[]
*/
private $objectInitializers;
/**
* Creates a validator for the given context.
*
* @param ExecutionContextInterface $context The execution context
* @param MetadataFactoryInterface $metadataFactory The factory for
* fetching the metadata
* 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())
{
$this->context = $context;
$this->defaultPropertyPath = $context->getPropertyPath();
$this->defaultGroups = array($context->getGroup() ?: Constraint::DEFAULT_GROUP);
$this->metadataFactory = $metadataFactory;
$this->validatorFactory = $validatorFactory;
$this->objectInitializers = $objectInitializers;
}
/**
* {@inheritdoc}
*/
public function atPath($path)
{
$this->defaultPropertyPath = $this->context->getPropertyPath($path);
return $this;
}
/**
* {@inheritdoc}
*/
public function validate($value, $constraints = null, $groups = null)
{
$groups = $groups ? $this->normalizeGroups($groups) : $this->defaultGroups;
$previousValue = $this->context->getValue();
$previousObject = $this->context->getObject();
$previousMetadata = $this->context->getMetadata();
$previousPath = $this->context->getPropertyPath();
$previousGroup = $this->context->getGroup();
$previousConstraint = null;
if ($this->context instanceof ExecutionContext || method_exists($this->context, 'getConstraint')) {
$previousConstraint = $this->context->getConstraint();
}
// 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);
}
$metadata = new GenericMetadata();
$metadata->addConstraints($constraints);
$this->validateGenericNode(
$value,
null,
is_object($value) ? spl_object_hash($value) : null,
$metadata,
$this->defaultPropertyPath,
$groups,
null,
TraversalStrategy::IMPLICIT,
$this->context
);
$this->context->setNode($previousValue, $previousObject, $previousMetadata, $previousPath);
$this->context->setGroup($previousGroup);
if (null !== $previousConstraint) {
$this->context->setConstraint($previousConstraint);
}
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)) {
$this->validateObject(
$value,
$this->defaultPropertyPath,
$groups,
TraversalStrategy::IMPLICIT,
$this->context
);
$this->context->setNode($previousValue, $previousObject, $previousMetadata, $previousPath);
$this->context->setGroup($previousGroup);
return $this;
}
// If an array is passed without explicit constraints, validate each
// object in the array
if (is_array($value)) {
$this->validateEachObjectIn(
$value,
$this->defaultPropertyPath,
$groups,
true,
$this->context
);
$this->context->setNode($previousValue, $previousObject, $previousMetadata, $previousPath);
$this->context->setGroup($previousGroup);
return $this;
}
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) {
// Cannot be UnsupportedMetadataException because of BC with
// Symfony < 2.5
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);
$propertyPath = PropertyPath::append($this->defaultPropertyPath, $propertyName);
$previousValue = $this->context->getValue();
$previousObject = $this->context->getObject();
$previousMetadata = $this->context->getMetadata();
$previousPath = $this->context->getPropertyPath();
$previousGroup = $this->context->getGroup();
foreach ($propertyMetadatas as $propertyMetadata) {
$propertyValue = $propertyMetadata->getPropertyValue($object);
$this->validateGenericNode(
$propertyValue,
$object,
$cacheKey.':'.$propertyName,
$propertyMetadata,
$propertyPath,
$groups,
null,
TraversalStrategy::IMPLICIT,
$this->context
);
}
$this->context->setNode($previousValue, $previousObject, $previousMetadata, $previousPath);
$this->context->setGroup($previousGroup);
return $this;
}
/**
* {@inheritdoc}
*/
public function validatePropertyValue($objectOrClass, $propertyName, $value, $groups = null)
{
$classMetadata = $this->metadataFactory->getMetadataFor($objectOrClass);
if (!$classMetadata instanceof ClassMetadataInterface) {
// Cannot be UnsupportedMetadataException because of BC with
// Symfony < 2.5
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)) {
$object = $objectOrClass;
$cacheKey = spl_object_hash($objectOrClass);
$propertyPath = PropertyPath::append($this->defaultPropertyPath, $propertyName);
} else {
// $objectOrClass contains a class name
$object = null;
$cacheKey = null;
$propertyPath = $this->defaultPropertyPath;
}
$previousValue = $this->context->getValue();
$previousObject = $this->context->getObject();
$previousMetadata = $this->context->getMetadata();
$previousPath = $this->context->getPropertyPath();
$previousGroup = $this->context->getGroup();
foreach ($propertyMetadatas as $propertyMetadata) {
$this->validateGenericNode(
$value,
$object,
$cacheKey.':'.$propertyName,
$propertyMetadata,
$propertyPath,
$groups,
null,
TraversalStrategy::IMPLICIT,
$this->context
);
}
$this->context->setNode($previousValue, $previousObject, $previousMetadata, $previousPath);
$this->context->setGroup($previousGroup);
return $this;
}
/**
* {@inheritdoc}
*/
public function getViolations()
{
return $this->context->getViolations();
}
/**
* Normalizes the given group or list of groups to an array.
*
* @param mixed $groups The groups to normalize
*
* @return array A group array
*/
protected function normalizeGroups($groups)
{
if (is_array($groups)) {
return $groups;
}
return array($groups);
}
/**
* Validates an object against the constraints defined for its class.
*
* If no metadata is available for the class, but the class is an instance
* of {@link \Traversable} and the selected traversal strategy allows
* 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 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
* and does not implement {@link \Traversable}
* or if traversal is disabled via the
* $traversalStrategy argument
* @throws UnsupportedMetadataException If the metadata returned by the
* metadata factory does not implement
* {@link ClassMetadataInterface}
*/
private function validateObject($object, $propertyPath, array $groups, $traversalStrategy, ExecutionContextInterface $context)
{
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)
));
}
$this->validateClassNode(
$object,
spl_object_hash($object),
$classMetadata,
$propertyPath,
$groups,
null,
$traversalStrategy,
$context
);
} catch (NoSuchMetadataException $e) {
// Rethrow if not Traversable
if (!$object instanceof \Traversable) {
throw $e;
}
// Rethrow unless IMPLICIT or TRAVERSE
if (!($traversalStrategy & (TraversalStrategy::IMPLICIT | TraversalStrategy::TRAVERSE))) {
throw $e;
}
$this->validateEachObjectIn(
$object,
$propertyPath,
$groups,
$traversalStrategy & TraversalStrategy::STOP_RECURSION,
$context
);
}
}
/**
* Validates each object in a collection against the constraints defined
* for their classes.
*
* If the parameter $recursive is set to true, nested {@link \Traversable}
* objects are iterated as well. Nested arrays are always iterated,
* regardless of the value of $recursive.
*
* @param array|\Traversable $collection The collection
* @param string $propertyPath The current property path
* @param string[] $groups The validated groups
* @param bool $stopRecursion Whether to disable
* recursive iteration. For
* backwards compatibility
* with Symfony < 2.5.
* @param ExecutionContextInterface $context The current execution context
*
* @see ClassNode
* @see CollectionNode
*/
private function validateEachObjectIn($collection, $propertyPath, array $groups, $stopRecursion, ExecutionContextInterface $context)
{
if ($stopRecursion) {
$traversalStrategy = TraversalStrategy::NONE;
} else {
$traversalStrategy = TraversalStrategy::IMPLICIT;
}
foreach ($collection as $key => $value) {
if (is_array($value)) {
// Arrays are always cascaded, independent of the specified
// traversal strategy
// (BC with Symfony < 2.5)
$this->validateEachObjectIn(
$value,
$propertyPath.'['.$key.']',
$groups,
$stopRecursion,
$context
);
continue;
}
// Scalar and null values in the collection are ignored
// (BC with Symfony < 2.5)
if (is_object($value)) {
$this->validateObject(
$value,
$propertyPath.'['.$key.']',
$groups,
$traversalStrategy,
$context
);
}
}
}
/**
* Validates a class node.
*
* A class node is a combination of an object with a {@link ClassMetadataInterface}
* instance. Each class node (conceptionally) has zero or more succeeding
* property nodes:
*
* (Article:class node)
* \
* ($title:property node)
*
* This method validates the passed objects against all constraints defined
* at class level. It furthermore triggers the validation of each of the
* class' properties against the constraints for that property.
*
* If the selected traversal strategy allows traversal, the object is
* iterated and each nested object is validated against its own constraints.
* The object is not traversed if traversal is disabled in the class
* metadata.
*
* If the passed groups contain the group "Default", the validator will
* check whether the "Default" group has been replaced by a group sequence
* in the class metadata. If this is the case, the group sequence is
* validated instead.
*
* @param object $object The validated object
* @param string $cacheKey The key for caching
* 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
* object should be validated
* @param string[]|null $cascadedGroups The groups in which
* cascaded objects should
* be validated
* @param int $traversalStrategy The strategy used for
* traversing the object
* @param ExecutionContextInterface $context The current execution context
*
* @throws UnsupportedMetadataException If a property metadata does not
* implement {@link PropertyMetadataInterface}
* @throws ConstraintDefinitionException If traversal was enabled but the
* object does not implement
* {@link \Traversable}
*
* @see TraversalStrategy
*/
private function validateClassNode($object, $cacheKey, ClassMetadataInterface $metadata = null, $propertyPath, array $groups, $cascadedGroups, $traversalStrategy, ExecutionContextInterface $context)
{
$context->setNode($object, $object, $metadata, $propertyPath);
if (!$context->isObjectInitialized($cacheKey)) {
foreach ($this->objectInitializers as $initializer) {
$initializer->initialize($object);
}
$context->markObjectAsInitialized($cacheKey);
}
foreach ($groups as $key => $group) {
// If the "Default" group is replaced by a group sequence, remember
// 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;
if ($context->isGroupValidated($cacheKey, $groupHash)) {
// Skip this group when validating the properties and when
// traversing the object
unset($groups[$key]);
continue;
}
$context->markGroupAsValidated($cacheKey, $groupHash);
// Replace the "Default" group by the group sequence defined
// for the class, if applicable.
// This is done after checking the cache, so that
// spl_object_hash() isn't called for this sequence and
// "Default" is used instead in the cache. This is useful
// if the getters below return different group sequences in
// every call.
if (Constraint::DEFAULT_GROUP === $group) {
if ($metadata->hasGroupSequence()) {
// The group sequence is statically defined for the class
$group = $metadata->getGroupSequence();
$defaultOverridden = true;
} elseif ($metadata->isGroupSequenceProvider()) {
// The group sequence is dynamically obtained from the validated
// object
/* @var \Symfony\Component\Validator\GroupSequenceProviderInterface $object */
$group = $object->getGroupSequence();
$defaultOverridden = true;
if (!$group instanceof GroupSequence) {
$group = new GroupSequence($group);
}
}
}
// If the groups (=[<G1,G2>,G3,G4]) contain a group sequence
// (=<G1,G2>), then call validateClassNode() with each entry of the
// group sequence and abort if necessary (G1, G2)
if ($group instanceof GroupSequence) {
$this->stepThroughGroupSequence(
$object,
$object,
$cacheKey,
$metadata,
$propertyPath,
$traversalStrategy,
$group,
$defaultOverridden ? Constraint::DEFAULT_GROUP : null,
$context
);
// Skip the group sequence when validating properties, because
// stepThroughGroupSequence() already validates the properties
unset($groups[$key]);
continue;
}
$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)) {
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)
));
}
$propertyValue = $propertyMetadata->getPropertyValue($object);
$this->validateGenericNode(
$propertyValue,
$object,
$cacheKey.':'.$propertyName,
$propertyMetadata,
PropertyPath::append($propertyPath, $propertyName),
$groups,
$cascadedGroups,
TraversalStrategy::IMPLICIT,
$context
);
}
}
// If no specific traversal strategy was requested when this method
// was called, use the traversal strategy of the class' metadata
if ($traversalStrategy & TraversalStrategy::IMPLICIT) {
// Keep the STOP_RECURSION flag, if it was set
$traversalStrategy = $metadata->getTraversalStrategy()
| ($traversalStrategy & TraversalStrategy::STOP_RECURSION);
}
// Traverse only if IMPLICIT or TRAVERSE
if (!($traversalStrategy & (TraversalStrategy::IMPLICIT | TraversalStrategy::TRAVERSE))) {
return;
}
// If IMPLICIT, stop unless we deal with a Traversable
if ($traversalStrategy & TraversalStrategy::IMPLICIT && !$object instanceof \Traversable) {
return;
}
// If TRAVERSE, fail if we have no Traversable
if (!$object instanceof \Traversable) {
// Must throw a ConstraintDefinitionException for backwards
// compatibility reasons with Symfony < 2.5
throw new ConstraintDefinitionException(sprintf(
'Traversal was enabled for "%s", but this class '.
'does not implement "\Traversable".',
get_class($object)
));
}
$this->validateEachObjectIn(
$object,
$propertyPath,
$groups,
$traversalStrategy & TraversalStrategy::STOP_RECURSION,
$context
);
}
/**
* Validates a node that is not a class node.
*
* Currently, two such node types exist:
*
* - property nodes, which consist of the value of an object's
* property together with a {@link PropertyMetadataInterface} instance
* - generic nodes, which consist of a value and some arbitrary
* constraints defined in a {@link MetadataInterface} container
*
* In both cases, the value is validated against all constraints defined
* in the passed metadata object. Then, if the value is an instance of
* {@link \Traversable} and the selected traversal strategy permits it,
* the value is traversed and each nested object validated against its own
* constraints. Arrays are always traversed.
*
* @param mixed $value The validated value
* @param object|null $object The current object
* @param string $cacheKey The key for caching
* 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
* value should be validated
* @param string[]|null $cascadedGroups The groups in which
* cascaded objects should
* be validated
* @param int $traversalStrategy The strategy used for
* traversing the value
* @param ExecutionContextInterface $context The current execution context
*
* @see TraversalStrategy
*/
private function validateGenericNode($value, $object, $cacheKey, MetadataInterface $metadata = null, $propertyPath, array $groups, $cascadedGroups, $traversalStrategy, ExecutionContextInterface $context)
{
$context->setNode($value, $object, $metadata, $propertyPath);
foreach ($groups as $key => $group) {
if ($group instanceof GroupSequence) {
$this->stepThroughGroupSequence(
$value,
$object,
$cacheKey,
$metadata,
$propertyPath,
$traversalStrategy,
$group,
null,
$context
);
// Skip the group sequence when cascading, as the cascading
// logic is already done in stepThroughGroupSequence()
unset($groups[$key]);
continue;
}
$this->validateInGroup($value, $cacheKey, $metadata, $group, $context);
}
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)) {
return;
}
// If no specific traversal strategy was requested when this method
// was called, use the traversal strategy of the node's metadata
if ($traversalStrategy & TraversalStrategy::IMPLICIT) {
// Keep the STOP_RECURSION flag, if it was set
$traversalStrategy = $metadata->getTraversalStrategy()
| ($traversalStrategy & TraversalStrategy::STOP_RECURSION);
}
// 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)) {
// Arrays are always traversed, independent of the specified
// traversal strategy
// (BC with Symfony < 2.5)
$this->validateEachObjectIn(
$value,
$propertyPath,
$cascadedGroups,
$traversalStrategy & TraversalStrategy::STOP_RECURSION,
$context
);
return;
}
// If the value is a scalar, pass it anyway, because we want
// a NoSuchMetadataException to be thrown in that case
// (BC with Symfony < 2.5)
$this->validateObject(
$value,
$propertyPath,
$cascadedGroups,
$traversalStrategy,
$context
);
// Currently, the traversal strategy can only be TRAVERSE for a
// generic node if the cascading strategy is CASCADE. Thus, traversable
// objects will always be handled within validateObject() and there's
// nothing more to do here.
// see GenericMetadata::addConstraint()
}
/**
* Sequentially validates a node's value in each group of a group sequence.
*
* If any of the constraints generates a violation, subsequent groups in the
* group sequence are skipped.
*
* @param mixed $value The validated value
* @param object|null $object The current object
* @param string $cacheKey The key for caching
* the validated value
* @param MetadataInterface $metadata The metadata of the
* value
* @param string $propertyPath The property path leading
* to the value
* @param int $traversalStrategy The strategy used for
* traversing the value
* @param GroupSequence $groupSequence The group sequence
* @param string|null $cascadedGroup The group that should
* be passed to cascaded
* objects instead of
* 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;
foreach ($groupSequence->groups as $groupInSequence) {
$groups = array($groupInSequence);
if ($metadata instanceof ClassMetadataInterface) {
$this->validateClassNode(
$value,
$cacheKey,
$metadata,
$propertyPath,
$groups,
$cascadedGroups,
$traversalStrategy,
$context
);
} else {
$this->validateGenericNode(
$value,
$object,
$cacheKey,
$metadata,
$propertyPath,
$groups,
$cascadedGroups,
$traversalStrategy,
$context
);
}
// Abort sequence validation if a violation was generated
if (count($context->getViolations()) > $violationCount) {
break;
}
}
}
/**
* Validates a node's value against all constraints in the given group.
*
* @param mixed $value The validated value
* @param string $cacheKey The key for caching the
* validated value
* @param MetadataInterface $metadata The metadata of the value
* @param string $group The group to validate
* @param ExecutionContextInterface $context The execution context
*/
private function validateInGroup($value, $cacheKey, MetadataInterface $metadata, $group, ExecutionContextInterface $context)
{
$context->setGroup($group);
foreach ($metadata->findConstraints($group) as $constraint) {
// Prevent duplicate validation of constraints, in the case
// that constraints belong to multiple validated groups
if (null !== $cacheKey) {
$constraintHash = spl_object_hash($constraint);
if ($context->isConstraintValidated($cacheKey, $constraintHash)) {
continue;
}
$context->markConstraintAsValidated($cacheKey, $constraintHash);
}
$context->setConstraint($constraint);
$validator = $this->validatorFactory->getInstance($constraint);
$validator->initialize($context);
$validator->validate($value, $constraint);
}
}
}

View file

@ -0,0 +1,186 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Validator\Validator;
use Symfony\Component\Validator\Constraint;
use Symfony\Component\Validator\Constraints\GroupSequence;
use Symfony\Component\Validator\Constraints\Valid;
use Symfony\Component\Validator\ConstraintValidatorFactoryInterface;
use Symfony\Component\Validator\Context\ExecutionContextFactoryInterface;
use Symfony\Component\Validator\Context\ExecutionContextInterface;
use Symfony\Component\Validator\MetadataFactoryInterface;
use Symfony\Component\Validator\ObjectInitializerInterface;
use Symfony\Component\Validator\ValidatorInterface as LegacyValidatorInterface;
/**
* Recursive implementation of {@link ValidatorInterface}.
*
* @author Bernhard Schussek <bschussek@gmail.com>
*/
class RecursiveValidator implements ValidatorInterface, LegacyValidatorInterface
{
/**
* @var ExecutionContextFactoryInterface
*/
protected $contextFactory;
/**
* @var MetadataFactoryInterface
*/
protected $metadataFactory;
/**
* @var ConstraintValidatorFactoryInterface
*/
protected $validatorFactory;
/**
* @var ObjectInitializerInterface[]
*/
protected $objectInitializers;
/**
* Creates a new validator.
*
* @param ExecutionContextFactoryInterface $contextFactory The factory for
* creating new contexts
* @param MetadataFactoryInterface $metadataFactory The factory for
* fetching the metadata
* of validated objects
* @param ConstraintValidatorFactoryInterface $validatorFactory The factory for creating
* constraint validators
* @param ObjectInitializerInterface[] $objectInitializers The object initializers
*/
public function __construct(ExecutionContextFactoryInterface $contextFactory, MetadataFactoryInterface $metadataFactory, ConstraintValidatorFactoryInterface $validatorFactory, array $objectInitializers = array())
{
$this->contextFactory = $contextFactory;
$this->metadataFactory = $metadataFactory;
$this->validatorFactory = $validatorFactory;
$this->objectInitializers = $objectInitializers;
}
/**
* {@inheritdoc}
*/
public function startContext($root = null)
{
return new RecursiveContextualValidator(
$this->contextFactory->createContext($this, $root),
$this->metadataFactory,
$this->validatorFactory,
$this->objectInitializers
);
}
/**
* {@inheritdoc}
*/
public function inContext(ExecutionContextInterface $context)
{
return new RecursiveContextualValidator(
$context,
$this->metadataFactory,
$this->validatorFactory,
$this->objectInitializers
);
}
/**
* {@inheritdoc}
*/
public function getMetadataFor($object)
{
return $this->metadataFactory->getMetadataFor($object);
}
/**
* {@inheritdoc}
*/
public function hasMetadataFor($object)
{
return $this->metadataFactory->hasMetadataFor($object);
}
/**
* {@inheritdoc}
*/
public function validate($value, $groups = null, $traverse = false, $deep = false)
{
$numArgs = func_num_args();
// Use new signature if constraints are given in the second argument
if (self::testConstraints($groups) && ($numArgs < 3 || 3 === $numArgs && self::testGroups($traverse))) {
// Rename to avoid total confusion ;)
$constraints = $groups;
$groups = $traverse;
} else {
@trigger_error('The Symfony\Component\Validator\ValidatorInterface::validate method is deprecated in version 2.5 and will be removed in version 3.0. Use the Symfony\Component\Validator\Validator\ValidatorInterface::validate method instead.', E_USER_DEPRECATED);
$constraints = new Valid(array('traverse' => $traverse, 'deep' => $deep));
}
return $this->startContext($value)
->validate($value, $constraints, $groups)
->getViolations();
}
/**
* {@inheritdoc}
*/
public function validateProperty($object, $propertyName, $groups = null)
{
return $this->startContext($object)
->validateProperty($object, $propertyName, $groups)
->getViolations();
}
/**
* {@inheritdoc}
*/
public function validatePropertyValue($objectOrClass, $propertyName, $value, $groups = null)
{
// If a class name is passed, take $value as root
return $this->startContext(is_object($objectOrClass) ? $objectOrClass : $value)
->validatePropertyValue($objectOrClass, $propertyName, $value, $groups)
->getViolations();
}
/**
* {@inheritdoc}
*/
public function validateValue($value, $constraints, $groups = null)
{
@trigger_error('The '.__METHOD__.' method is deprecated in version 2.5 and will be removed in version 3.0. Use the Symfony\Component\Validator\Validator\ValidatorInterface::validate method instead.', E_USER_DEPRECATED);
return $this->validate($value, $constraints, $groups);
}
/**
* {@inheritdoc}
*/
public function getMetadataFactory()
{
@trigger_error('The '.__METHOD__.' method is deprecated in version 2.5 and will be removed in version 3.0. Use the Symfony\Component\Validator\Validator\ValidatorInterface::getMetadataFor or Symfony\Component\Validator\Validator\ValidatorInterface::hasMetadataFor method instead.', E_USER_DEPRECATED);
return $this->metadataFactory;
}
private static function testConstraints($constraints)
{
return null === $constraints || $constraints instanceof Constraint || (is_array($constraints) && (0 === count($constraints) || current($constraints) instanceof Constraint));
}
private static function testGroups($groups)
{
return null === $groups || is_string($groups) || $groups instanceof GroupSequence || (is_array($groups) && (0 === count($groups) || is_string(current($groups)) || current($groups) instanceof GroupSequence));
}
}

View file

@ -0,0 +1,99 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Validator\Validator;
use Symfony\Component\Validator\Constraint;
use Symfony\Component\Validator\ConstraintViolationListInterface;
use Symfony\Component\Validator\Context\ExecutionContextInterface;
use Symfony\Component\Validator\Mapping\Factory\MetadataFactoryInterface;
/**
* Validates PHP values against constraints.
*
* @author Bernhard Schussek <bschussek@gmail.com>
*/
interface ValidatorInterface extends MetadataFactoryInterface
{
/**
* Validates a value against a constraint or a list of constraints.
*
* If no constraint is passed, the constraint
* {@link \Symfony\Component\Validator\Constraints\Valid} is assumed.
*
* @param mixed $value The value to validate
* @param Constraint|Constraint[] $constraints The constraint(s) to validate
* against
* @param array|null $groups The validation groups to
* validate. If none is given,
* "Default" is assumed
*
* @return ConstraintViolationListInterface A list of constraint violations
* If the list is empty, validation
* succeeded
*/
public function validate($value, $constraints = null, $groups = null);
/**
* Validates a property of an object against the constraints specified
* for this property.
*
* @param object $object The object
* @param string $propertyName The name of the validated property
* @param array|null $groups The validation groups to validate. If
* none is given, "Default" is assumed
*
* @return ConstraintViolationListInterface A list of constraint violations
* If the list is empty, validation
* succeeded
*/
public function validateProperty($object, $propertyName, $groups = null);
/**
* Validates a value against the constraints specified for an object's
* property.
*
* @param object|string $objectOrClass The object or its class name
* @param string $propertyName The name of the property
* @param mixed $value The value to validate against the
* property's constraints
* @param array|null $groups The validation groups to validate. If
* none is given, "Default" is assumed
*
* @return ConstraintViolationListInterface A list of constraint violations
* If the list is empty, validation
* succeeded
*/
public function validatePropertyValue($objectOrClass, $propertyName, $value, $groups = null);
/**
* Starts a new validation context and returns a validator for that context.
*
* The returned validator collects all violations generated within its
* context. You can access these violations with the
* {@link ContextualValidatorInterface::getViolations()} method.
*
* @return ContextualValidatorInterface The validator for the new context
*/
public function startContext();
/**
* Returns a validator in the given execution context.
*
* The returned validator adds all generated violations to the given
* context.
*
* @param ExecutionContextInterface $context The execution context
*
* @return ContextualValidatorInterface The validator for that context
*/
public function inContext(ExecutionContextInterface $context);
}