Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2025-05-25 12:37
📄 ClassBasedInterface.php <?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; /* * An object backed by a PHP class. * * @author Bernhard Schussek <bschussek@gmail.com> / interface ClassBasedInterface { /* * Returns the name of the backing PHP class. * * @return string The name of the backing class. */ public function getClassName(); }	572 B	2024-07-17 10:22
📄 Constraint.php <?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; use Symfony\Component\Validator\Exception\InvalidOptionsException; use Symfony\Component\Validator\Exception\MissingOptionsException; use Symfony\Component\Validator\Exception\ConstraintDefinitionException; /* * Contains the properties of a constraint definition. * * A constraint can be defined on a class, an option or a getter method. * The Constraint class encapsulates all the configuration required for * validating this class, option or getter result successfully. * * Constraint instances are immutable and serializable. * * @author Bernhard Schussek <bschussek@gmail.com> * * @api / abstract class Constraint { /* * The name of the group given to all constraints with no explicit group * @var string / const DEFAULT_GROUP = 'Default'; /* * Marks a constraint that can be put onto classes * @var string / const CLASS_CONSTRAINT = 'class'; /* * Marks a constraint that can be put onto properties * @var string / const PROPERTY_CONSTRAINT = 'property'; /* * @var array / public $groups = array(self::DEFAULT_GROUP); /* * Initializes the constraint with options. * * You should pass an associative array. The keys should be the names of * existing properties in this class. The values should be the value for these * properties. * * Alternatively you can override the method getDefaultOption() to return the * name of an existing property. If no associative array is passed, this * property is set instead. * * You can force that certain options are set by overriding * getRequiredOptions() to return the names of these options. If any * option is not set here, an exception is thrown. * * @param mixed $options The options (as associative array) * or the value for the default * option (any other type) * * @throws InvalidOptionsException When you pass the names of non-existing * options * @throws MissingOptionsException When you don't pass any of the options * returned by getRequiredOptions() * @throws ConstraintDefinitionException When you don't pass an associative * array, but getDefaultOption() returns * null * * @api / public function __construct($options = null) { $invalidOptions = array(); $missingOptions = array_flip((array) $this->getRequiredOptions()); if (is_array($options) && count($options) >= 1 && isset($options['value']) && !property_exists($this, 'value')) { $options[$this->getDefaultOption()] = $options['value']; unset($options['value']); } if (is_array($options) && count($options) > 0 && is_string(key($options))) { foreach ($options as $option => $value) { if (property_exists($this, $option)) { $this->$option = $value; unset($missingOptions[$option]); } else { $invalidOptions[] = $option; } } } elseif (null !== $options && ! (is_array($options) && count($options) === 0)) { $option = $this->getDefaultOption(); if (null === $option) { throw new ConstraintDefinitionException( sprintf('No default option is configured for constraint %s', get_class($this)) ); } if (property_exists($this, $option)) { $this->$option = $options; unset($missingOptions[$option]); } else { $invalidOptions[] = $option; } } if (count($invalidOptions) > 0) { throw new InvalidOptionsException( sprintf('The options "%s" do not exist in constraint %s', implode('", "', $invalidOptions), get_class($this)), $invalidOptions ); } if (count($missingOptions) > 0) { throw new MissingOptionsException( sprintf('The options "%s" must be set for constraint %s', implode('", "', array_keys($missingOptions)), get_class($this)), array_keys($missingOptions) ); } $this->groups = (array) $this->groups; } /* * Unsupported operation. / public function __set($option, $value) { throw new InvalidOptionsException(sprintf('The option "%s" does not exist in constraint %s', $option, get_class($this)), array($option)); } /* * Adds the given group if this constraint is in the Default group * * @param string $group * * @api / public function addImplicitGroupName($group) { if (in_array(Constraint::DEFAULT_GROUP, $this->groups) && !in_array($group, $this->groups)) { $this->groups[] = $group; } } /* * Returns the name of the default option * * Override this method to define a default option. * * @return string * @see __construct() * * @api / public function getDefaultOption() { return null; } /* * Returns the name of the required options * * Override this method if you want to define required options. * * @return array * @see __construct() * * @api / public function getRequiredOptions() { return array(); } /* * Returns the name of the class that validates this constraint * * By default, this is the fully qualified name of the constraint class * suffixed with "Validator". You can override this method to change that * behaviour. * * @return string * * @api / public function validatedBy() { return get_class($this).'Validator'; } /* * Returns whether the constraint can be put onto classes, properties or * both * * This method should return one or more of the constants * Constraint::CLASS_CONSTRAINT and Constraint::PROPERTY_CONSTRAINT. * * @return string\|array One or more constant values * * @api */ public function getTargets() { return self::PROPERTY_CONSTRAINT; } }	6.64 KB	2024-07-17 10:22
📄 ConstraintValidator.php <?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; /* * Base class for constraint validators * * @author Bernhard Schussek <bschussek@gmail.com> * * @api / abstract class ConstraintValidator implements ConstraintValidatorInterface { /* * @var ExecutionContextInterface / protected $context; /* * {@inheritDoc} */ public function initialize(ExecutionContextInterface $context) { $this->context = $context; } }	700 B	2024-07-17 10:22
📄 ConstraintValidatorFactory.php <?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; use Symfony\Component\PropertyAccess\PropertyAccess; use Symfony\Component\PropertyAccess\PropertyAccessorInterface; use Symfony\Component\Validator\Constraints\ExpressionValidator; /* * Default implementation of the ConstraintValidatorFactoryInterface. * * This enforces the convention that the validatedBy() method on any * Constraint will return the class name of the ConstraintValidator that * should validate the Constraint. * * @author Bernhard Schussek <bschussek@gmail.com> / class ConstraintValidatorFactory implements ConstraintValidatorFactoryInterface { protected $validators = array(); /* * @var PropertyAccessorInterface / private $propertyAccessor; public function __construct(PropertyAccessorInterface $propertyAccessor = null) { $this->propertyAccessor = $propertyAccessor ?: PropertyAccess::createPropertyAccessor(); } /* * {@inheritDoc} */ public function getInstance(Constraint $constraint) { $className = $constraint->validatedBy(); // The second condition is a hack that is needed when CollectionValidator // calls itself recursively (Collection constraints can be nested). // Since the context of the validator is overwritten when initialize() // is called for the nested constraint, the outer validator is // acting on the wrong context when the nested validation terminates. // // A better solution - which should be approached in Symfony 3.0 - is to // remove the initialize() method and pass the context as last argument // to validate() instead. if (!isset($this->validators[$className]) \|\| 'Symfony\Component\Validator\Constraints\CollectionValidator' === $className) { $this->validators[$className] = 'validator.expression' === $className ? new ExpressionValidator($this->propertyAccessor) : new $className(); } return $this->validators[$className]; } }	2.24 KB	2024-07-17 10:22
📄 ConstraintValidatorFactoryInterface.php <?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; /* * Specifies an object able to return the correct ConstraintValidatorInterface * instance given a Constraint object. / interface ConstraintValidatorFactoryInterface { /* * Given a Constraint, this returns the ConstraintValidatorInterface * object that should be used to verify its validity. * * @param Constraint $constraint The source constraint * * @return ConstraintValidatorInterface */ public function getInstance(Constraint $constraint); }	775 B	2024-07-17 10:22
📄 ConstraintValidatorInterface.php <?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; /* * @author Bernhard Schussek <bschussek@gmail.com> * * @api / interface ConstraintValidatorInterface { /* * Initializes the constraint validator. * * @param ExecutionContextInterface $context The current validation context / public function initialize(ExecutionContextInterface $context); /* * Checks if the passed value is valid. * * @param mixed $value The value that should be validated * @param Constraint $constraint The constraint for the validation * * @api */ public function validate($value, Constraint $constraint); }	899 B	2024-07-17 10:22
📄 ConstraintViolation.php <?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; /* * Default implementation of {@ConstraintViolationInterface}. * * @author Bernhard Schussek <bschussek@gmail.com> / class ConstraintViolation implements ConstraintViolationInterface { /* * @var string / private $message; /* * @var string / private $messageTemplate; /* * @var array / private $messageParameters; /* * @var integer\|null / private $messagePluralization; /* * @var mixed / private $root; /* * @var string / private $propertyPath; /* * @var mixed / private $invalidValue; /* * @var mixed / private $code; /* * Creates a new constraint violation. * * @param string $message The violation message. * @param string $messageTemplate The raw violation message. * @param array $messageParameters The parameters to substitute * in the raw message. * @param mixed $root The value originally passed * to the validator. * @param string $propertyPath The property path from the * root value to the invalid * value. * @param mixed $invalidValue The invalid value causing the * violation. * @param integer\|null $messagePluralization The pluralization parameter. * @param mixed $code The error code of the * violation, if any. / public function __construct($message, $messageTemplate, array $messageParameters, $root, $propertyPath, $invalidValue, $messagePluralization = null, $code = null) { $this->message = $message; $this->messageTemplate = $messageTemplate; $this->messageParameters = $messageParameters; $this->messagePluralization = $messagePluralization; $this->root = $root; $this->propertyPath = $propertyPath; $this->invalidValue = $invalidValue; $this->code = $code; } /* * Converts the violation into a string for debugging purposes. * * @return string The violation as string. / public function __toString() { if (is_object($this->root)) { $class = get_class($this->root); } elseif (is_array($this->root)) { $class = "Array"; } else { $class = (string) $this->root; } $propertyPath = (string) $this->propertyPath; $code = $this->code; if ('' !== $propertyPath && '[' !== $propertyPath[0] && '' !== $class) { $class .= '.'; } if (!empty($code)) { $code = ' (code '.$code.')'; } return $class.$propertyPath.":\n ".$this->getMessage().$code; } /* * {@inheritDoc} / public function getMessageTemplate() { return $this->messageTemplate; } /* * {@inheritDoc} / public function getMessageParameters() { return $this->messageParameters; } /* * {@inheritDoc} / public function getMessagePluralization() { return $this->messagePluralization; } /* * {@inheritDoc} / public function getMessage() { return $this->message; } /* * {@inheritDoc} / public function getRoot() { return $this->root; } /* * {@inheritDoc} / public function getPropertyPath() { return $this->propertyPath; } /* * {@inheritDoc} / public function getInvalidValue() { return $this->invalidValue; } /* * {@inheritDoc} */ public function getCode() { return $this->code; } }	4.23 KB	2024-07-17 10:22
📄 ConstraintViolationInterface.php <?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; /* * A violation of a constraint that happened during validation. * * For each constraint that fails during validation one or more violations are * created. The violations store the violation message, the path to the failing * element in the validation graph and the root element that was originally * passed to the validator. For example, take the following graph: * * <pre> * (Person)---(firstName: string) * \ * (address: Address)---(street: string) * </pre> * * If the <tt>Person</tt> object is validated and validation fails for the * "firstName" property, the generated violation has the <tt>Person</tt> * instance as root and the property path "firstName". If validation fails * for the "street" property of the related <tt>Address</tt> instance, the root * element is still the person, but the property path is "address.street". * * @author Bernhard Schussek <bschussek@gmail.com> * * @api / interface ConstraintViolationInterface { /* * Returns the violation message. * * @return string The violation message. * * @api / public function getMessage(); /* * Returns the raw violation message. * * The raw violation message contains placeholders for the parameters * returned by {@link getMessageParameters}. Typically you'll pass the * message template and parameters to a translation engine. * * @return string The raw violation message. * * @api / public function getMessageTemplate(); /* * Returns the parameters to be inserted into the raw violation message. * * @return array A possibly empty list of parameters indexed by the names * that appear in the message template. * * @see getMessageTemplate * * @api / public function getMessageParameters(); /* * Returns a number for pluralizing the violation message. * * For example, the message template could have different translation based * on a parameter "choices": * * <ul> * <li>Please select exactly one entry. (choices=1)</li> * <li>Please select two entries. (choices=2)</li> * </ul> * * This method returns the value of the parameter for choosing the right * pluralization form (in this case "choices"). * * @return integer\|null The number to use to pluralize of the message. / public function getMessagePluralization(); /* * Returns the root element of the validation. * * @return mixed The value that was passed originally to the validator when * the validation was started. Because the validator traverses * the object graph, the value at which the violation occurs * is not necessarily the value that was originally validated. * * @api / public function getRoot(); /* * Returns the property path from the root element to the violation. * * @return string The property path indicates how the validator reached * the invalid value from the root element. If the root * element is a <tt>Person</tt> instance with a property * "address" that contains an <tt>Address</tt> instance * with an invalid property "street", the generated property * path is "address.street". Property access is denoted by * dots, while array access is denoted by square brackets, * for example "addresses[1].street". * * @api / public function getPropertyPath(); /* * Returns the value that caused the violation. * * @return mixed The invalid value that caused the validated constraint to * fail. * * @api / public function getInvalidValue(); /* * Returns a machine-digestible error code for the violation. * * @return mixed The error code. */ public function getCode(); }	4.25 KB	2024-07-17 10:22
📄 ConstraintViolationList.php <?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; /* * Default implementation of {@ConstraintViolationListInterface}. * * @author Bernhard Schussek <bschussek@gmail.com> / class ConstraintViolationList implements \IteratorAggregate, ConstraintViolationListInterface { /* * @var ConstraintViolationInterface[] / private $violations = array(); /* * Creates a new constraint violation list. * * @param ConstraintViolationInterface[] $violations The constraint violations to add to the list / public function __construct(array $violations = array()) { foreach ($violations as $violation) { $this->add($violation); } } /* * Converts the violation into a string for debugging purposes. * * @return string The violation as string. / public function __toString() { $string = ''; foreach ($this->violations as $violation) { $string .= $violation."\n"; } return $string; } /* * {@inheritDoc} / public function add(ConstraintViolationInterface $violation) { $this->violations[] = $violation; } /* * {@inheritDoc} / public function addAll(ConstraintViolationListInterface $otherList) { foreach ($otherList as $violation) { $this->violations[] = $violation; } } /* * {@inheritDoc} / public function get($offset) { if (!isset($this->violations[$offset])) { throw new \OutOfBoundsException(sprintf('The offset "%s" does not exist.', $offset)); } return $this->violations[$offset]; } /* * {@inheritDoc} / public function has($offset) { return isset($this->violations[$offset]); } /* * {@inheritDoc} / public function set($offset, ConstraintViolationInterface $violation) { $this->violations[$offset] = $violation; } /* * {@inheritDoc} / public function remove($offset) { unset($this->violations[$offset]); } /* * {@inheritDoc} / public function getIterator() { return new \ArrayIterator($this->violations); } /* * {@inheritDoc} / public function count() { return count($this->violations); } /* * {@inheritDoc} / public function offsetExists($offset) { return $this->has($offset); } /* * {@inheritDoc} / public function offsetGet($offset) { return $this->get($offset); } /* * {@inheritDoc} / public function offsetSet($offset, $violation) { if (null === $offset) { $this->add($violation); } else { $this->set($offset, $violation); } } /* * {@inheritDoc} */ public function offsetUnset($offset) { $this->remove($offset); } }	3.17 KB	2024-07-17 10:22
📄 ConstraintViolationListInterface.php <?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; /* * A list of constraint violations. * * @author Bernhard Schussek <bschussek@gmail.com> * * @api / interface ConstraintViolationListInterface extends \Traversable, \Countable, \ArrayAccess { /* * Adds a constraint violation to this list. * * @param ConstraintViolationInterface $violation The violation to add. * * @api / public function add(ConstraintViolationInterface $violation); /* * Merges an existing violation list into this list. * * @param ConstraintViolationListInterface $otherList The list to merge. * * @api / public function addAll(ConstraintViolationListInterface $otherList); /* * Returns the violation at a given offset. * * @param integer $offset The offset of the violation. * * @return ConstraintViolationInterface The violation. * * @throws \OutOfBoundsException If the offset does not exist. * * @api / public function get($offset); /* * Returns whether the given offset exists. * * @param integer $offset The violation offset. * * @return Boolean Whether the offset exists. * * @api / public function has($offset); /* * Sets a violation at a given offset. * * @param integer $offset The violation offset. * @param ConstraintViolationInterface $violation The violation. * * @api / public function set($offset, ConstraintViolationInterface $violation); /* * Removes a violation at a given offset. * * @param integer $offset The offset to remove. * * @api */ public function remove($offset); }	1.96 KB	2024-07-17 10:22
📁 Constraints	-	2025-05-25 12:37
📄 DefaultTranslator.php <?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; use Symfony\Component\Validator\Exception\BadMethodCallException; use Symfony\Component\Validator\Exception\InvalidArgumentException; use Symfony\Component\Translation\TranslatorInterface; /* * Simple translator implementation that simply replaces the parameters in * the message IDs. * * Example usage: * * $translator = new DefaultTranslator(); * * echo $translator->trans( * 'This is a {{ var }}.', * array('{{ var }}' => 'donkey') * ); * * // -> This is a donkey. * * echo $translator->transChoice( * 'This is {{ count }} donkey.\|These are {{ count }} donkeys.', * 3, * array('{{ count }}' => 'three') * ); * * // -> These are three donkeys. * * This translator does not support message catalogs, translation domains or * locales. Instead, it implements a subset of the capabilities of * {@link \Symfony\Component\Translation\Translator} and can be used in places * where translation is not required by default but should be optional. * * @author Bernhard Schussek <bschussek@gmail.com> / class DefaultTranslator implements TranslatorInterface { /* * Interpolates the given message. * * Parameters are replaced in the message in the same manner that * {@link strtr()} uses. * * Example usage: * * $translator = new DefaultTranslator(); * * echo $translator->trans( * 'This is a {{ var }}.', * array('{{ var }}' => 'donkey') * ); * * // -> This is a donkey. * * @param string $id The message id * @param array $parameters An array of parameters for the message * @param string $domain Ignored * @param string $locale Ignored * * @return string The interpolated string / public function trans($id, array $parameters = array(), $domain = null, $locale = null) { return strtr($id, $parameters); } /* * Interpolates the given choice message by choosing a variant according to a number. * * The variants are passed in the message ID using the format * "<singular>\|<plural>". "<singular>" is chosen if the passed $number is * exactly 1. "<plural>" is chosen otherwise. * * This format is consistent with the format supported by * {@link \Symfony\Component\Translation\Translator}, but it does not * have the same expressiveness. While Translator supports intervals in * message translations, which are needed for languages other than English, * this translator does not. You should use Translator or a custom * implementation of {@link TranslatorInterface} if you need this or similar * functionality. * * Example usage: * * echo $translator->transChoice( * 'This is {{ count }} donkey.\|These are {{ count }} donkeys.', * 0, * array('{{ count }}' => 0) * ); * * // -> These are 0 donkeys. * * echo $translator->transChoice( * 'This is {{ count }} donkey.\|These are {{ count }} donkeys.', * 1, * array('{{ count }}' => 1) * ); * * // -> This is 1 donkey. * * echo $translator->transChoice( * 'This is {{ count }} donkey.\|These are {{ count }} donkeys.', * 3, * array('{{ count }}' => 3) * ); * * // -> These are 3 donkeys. * * @param string $id The message id * @param integer $number The number to use to find the index of the message * @param array $parameters An array of parameters for the message * @param string $domain Ignored * @param string $locale Ignored * * @return string The translated string * * @throws InvalidArgumentException If the message id does not have the format * "singular\|plural". / public function transChoice($id, $number, array $parameters = array(), $domain = null, $locale = null) { $ids = explode('\|', $id); if (1 == $number) { return strtr($ids[0], $parameters); } if (!isset($ids[1])) { throw new InvalidArgumentException(sprintf('The message "%s" cannot be pluralized, because it is missing a plural (e.g. "There is one apple\|There are %%count%% apples").', $id)); } return strtr($ids[1], $parameters); } /* * Not supported. * * @param string $locale The locale * * @throws BadMethodCallException / public function setLocale($locale) { throw new BadMethodCallException('Unsupported method.'); } /* * Returns the locale of the translator. * * @return string Always returns 'en' */ public function getLocale() { return 'en'; } }	5.12 KB	2024-07-17 10:22
📁 Exception	-	2025-05-25 12:37
📄 ExecutionContext.php <?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; use Symfony\Component\Translation\TranslatorInterface; /* * Default implementation of {@link ExecutionContextInterface}. * * This class is immutable by design. * * @author Fabien Potencier <fabien@symfony.com> * @author Bernhard Schussek <bschussek@gmail.com> / class ExecutionContext implements ExecutionContextInterface { /* * @var GlobalExecutionContextInterface / private $globalContext; /* * @var TranslatorInterface / private $translator; /* * @var null\|string / private $translationDomain; /* * @var MetadataInterface / private $metadata; /* * @var mixed / private $value; /* * @var string / private $group; /* * @var string / private $propertyPath; /* * Creates a new execution context. * * @param GlobalExecutionContextInterface $globalContext The global context storing node-independent state. * @param TranslatorInterface $translator The translator for translating violation messages. * @param null\|string $translationDomain The domain of the validation messages. * @param MetadataInterface $metadata The metadata of the validated node. * @param mixed $value The value of the validated node. * @param string $group The current validation group. * @param string $propertyPath The property path to the current node. / public function __construct(GlobalExecutionContextInterface $globalContext, TranslatorInterface $translator, $translationDomain = null, MetadataInterface $metadata = null, $value = null, $group = null, $propertyPath = '') { if (null === $group) { $group = Constraint::DEFAULT_GROUP; } $this->globalContext = $globalContext; $this->translator = $translator; $this->translationDomain = $translationDomain; $this->metadata = $metadata; $this->value = $value; $this->propertyPath = $propertyPath; $this->group = $group; } /* * {@inheritdoc} / public function addViolation($message, array $params = array(), $invalidValue = null, $pluralization = null, $code = null) { if (null === $pluralization) { $translatedMessage = $this->translator->trans($message, $params, $this->translationDomain); } else { try { $translatedMessage = $this->translator->transChoice($message, $pluralization, $params, $this->translationDomain); } catch (\InvalidArgumentException $e) { $translatedMessage = $this->translator->trans($message, $params, $this->translationDomain); } } $this->globalContext->getViolations()->add(new ConstraintViolation( $translatedMessage, $message, $params, $this->globalContext->getRoot(), $this->propertyPath, // check using func_num_args() to allow passing null values func_num_args() >= 3 ? $invalidValue : $this->value, $pluralization, $code )); } /* * {@inheritdoc} / public function addViolationAt($subPath, $message, array $params = array(), $invalidValue = null, $pluralization = null, $code = null) { $this->globalContext->getViolations()->add(new ConstraintViolation( null === $pluralization ? $this->translator->trans($message, $params, $this->translationDomain) : $this->translator->transChoice($message, $pluralization, $params, $this->translationDomain), $message, $params, $this->globalContext->getRoot(), $this->getPropertyPath($subPath), // check using func_num_args() to allow passing null values func_num_args() >= 4 ? $invalidValue : $this->value, $pluralization, $code )); } /* * {@inheritdoc} / public function getViolations() { return $this->globalContext->getViolations(); } /* * {@inheritdoc} / public function getRoot() { return $this->globalContext->getRoot(); } /* * {@inheritdoc} / public function getPropertyPath($subPath = '') { if ('' != $subPath && '' !== $this->propertyPath && '[' !== $subPath[0]) { return $this->propertyPath.'.'.$subPath; } return $this->propertyPath.$subPath; } /* * {@inheritdoc} / public function getClassName() { if ($this->metadata instanceof ClassBasedInterface) { return $this->metadata->getClassName(); } return null; } /* * {@inheritdoc} / public function getPropertyName() { if ($this->metadata instanceof PropertyMetadataInterface) { return $this->metadata->getPropertyName(); } return null; } /* * {@inheritdoc} / public function getValue() { return $this->value; } /* * {@inheritdoc} / public function getGroup() { return $this->group; } /* * {@inheritdoc} / public function getMetadata() { return $this->metadata; } /* * {@inheritdoc} / public function getMetadataFor($value) { return $this->globalContext->getMetadataFactory()->getMetadataFor($value); } /* * {@inheritdoc} / public function validate($value, $subPath = '', $groups = null, $traverse = false, $deep = false) { $propertyPath = $this->getPropertyPath($subPath); foreach ($this->resolveGroups($groups) as $group) { $this->globalContext->getVisitor()->validate($value, $group, $propertyPath, $traverse, $deep); } } /* * {@inheritdoc} / public function validateValue($value, $constraints, $subPath = '', $groups = null) { $constraints = is_array($constraints) ? $constraints : array($constraints); if (null === $groups && '' === $subPath) { $context = clone $this; $context->value = $value; $context->executeConstraintValidators($value, $constraints); return; } $propertyPath = $this->getPropertyPath($subPath); foreach ($this->resolveGroups($groups) as $group) { $context = clone $this; $context->value = $value; $context->group = $group; $context->propertyPath = $propertyPath; $context->executeConstraintValidators($value, $constraints); } } /* * {@inheritdoc} / public function getMetadataFactory() { return $this->globalContext->getMetadataFactory(); } /* * Executes the validators of the given constraints for the given value. * * @param mixed $value The value to validate. * @param Constraint[] $constraints The constraints to match against. / private function executeConstraintValidators($value, array $constraints) { foreach ($constraints as $constraint) { $validator = $this->globalContext->getValidatorFactory()->getInstance($constraint); $validator->initialize($this); $validator->validate($value, $constraint); } } /* * Returns an array of group names. * * @param null\|string\|string[] $groups The groups to resolve. If a single string is * passed, it is converted to an array. If null * is passed, an array containing the current * group of the context is returned. * * @return array An array of validation groups. */ private function resolveGroups($groups) { return $groups ? (array) $groups : (array) $this->group; } }	8.3 KB	2024-07-17 10:22
📄 ExecutionContextInterface.php <?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; /* * Stores the validator's state during validation. * * For example, let's validate the following object graph: * * <pre> * (Person)---($firstName: string) * \ * ($address: Address)---($street: string) * </pre> * * We validate the <tt>Person</tt> instance, which becomes the "root" of the * validation run (see {@link getRoot}). The state of the context after the * first step will be like this: * * <pre> * (Person)---($firstName: string) * ^ \ * ($address: Address)---($street: string) * </pre> * * The validator is stopped at the <tt>Person</tt> node, both the root and the * value (see {@link getValue}) of the context point to the <tt>Person</tt> * instance. The property path is empty at this point (see {@link getPropertyPath}). * The metadata of the context is the metadata of the <tt>Person</tt> node * (see {@link getMetadata}). * * After advancing to the property <tt>$firstName</tt> of the <tt>Person</tt> * instance, the state of the context looks like this: * * <pre> * (Person)---($firstName: string) * \ ^ * ($address: Address)---($street: string) * </pre> * * The validator is stopped at the property <tt>$firstName</tt>. The root still * points to the <tt>Person</tt> instance, because this is where the validation * started. The property path is now "firstName" and the current value is the * value of that property. * * After advancing to the <tt>$address</tt> property and then to the * <tt>$street</tt> property of the <tt>Address</tt> instance, the context state * looks like this: * * <pre> * (Person)---($firstName: string) * \ * ($address: Address)---($street: string) * ^ * </pre> * * The validator is stopped at the property <tt>$street</tt>. The root still * points to the <tt>Person</tt> instance, but the property path is now * "address.street" and the validated value is the value of that property. * * Apart from the root, the property path and the currently validated value, * the execution context also knows the metadata of the current node (see * {@link getMetadata}) which for example returns a {@link Mapping\PropertyMetadata} * or a {@link Mapping\ClassMetadata} object. he context also contains the * validation group that is currently being validated (see {@link getGroup}) and * the violations that happened up until now (see {@link getViolations}). * * Apart from reading the execution context, you can also use * {@link addViolation} or {@link addViolationAt} to add new violations and * {@link validate} or {@link validateValue} to validate values that the * validator otherwise would not reach. * * @author Bernhard Schussek <bschussek@gmail.com> * * @api / interface ExecutionContextInterface { /* * Adds a violation at the current node of the validation graph. * * @param string $message The error message. * @param array $params The parameters substituted in the error message. * @param mixed $invalidValue The invalid, validated value. * @param integer\|null $pluralization The number to use to pluralize of the message. * @param integer\|null $code The violation code. * * @api / public function addViolation($message, array $params = array(), $invalidValue = null, $pluralization = null, $code = null); /* * Adds a violation at the validation graph node with the given property * path relative to the current property path. * * @param string $subPath The relative property path for the violation. * @param string $message The error message. * @param array $params The parameters substituted in the error message. * @param mixed $invalidValue The invalid, validated value. * @param integer\|null $pluralization The number to use to pluralize of the message. * @param integer\|null $code The violation code. * * @api / public function addViolationAt($subPath, $message, array $params = array(), $invalidValue = null, $pluralization = null, $code = null); /* * Validates the given value within the scope of the current validation. * * The value may be any value recognized by the used metadata factory * (see {@link MetadataFactoryInterface::getMetadata}), or an array or a * traversable object of such values. * * Usually you validate a value that is not the current node of the * execution context. For this case, you can pass the {@link $subPath} * argument which is appended to the current property path when a violation * is created. For example, take the following object graph: * * <pre> * (Person)---($address: Address)---($phoneNumber: PhoneNumber) * ^ * </pre> * * When the execution context stops at the <tt>Person</tt> instance, the * property path is "address". When you validate the <tt>PhoneNumber</tt> * instance now, pass "phoneNumber" as sub path to correct the property path * to "address.phoneNumber": * * <pre> * $context->validate($address->phoneNumber, 'phoneNumber'); * </pre> * * Any violations generated during the validation will be added to the * violation list that you can access with {@link getViolations}. * * @param mixed $value The value to validate. * @param string $subPath The path to append to the context's property path. * @param null\|string\|string[] $groups The groups to validate in. If you don't pass any * groups here, the current group of the context * will be used. * @param Boolean $traverse Whether to traverse the value if it is an array * or an instance of <tt>\Traversable</tt>. * @param Boolean $deep Whether to traverse the value recursively if * it is a collection of collections. / public function validate($value, $subPath = '', $groups = null, $traverse = false, $deep = false); /* * Validates a value against a constraint. * * Use the parameter <tt>$subPath</tt> to adapt the property path for the * validated value. For example, take the following object graph: * * <pre> * (Person)---($address: Address)---($street: string) * ^ * </pre> * * When the validator validates the <tt>Address</tt> instance, the * property path stored in the execution context is "address". When you * manually validate the property <tt>$street</tt> now, pass the sub path * "street" to adapt the full property path to "address.street": * * <pre> * $context->validate($address->street, new NotNull(), 'street'); * </pre> * * @param mixed $value The value to validate. * @param Constraint\|Constraint[] $constraints The constraint(s) to validate against. * @param string $subPath The path to append to the context's property path. * @param null\|string\|string[] $groups The groups to validate in. If you don't pass any * groups here, the current group of the context * will be used. / public function validateValue($value, $constraints, $subPath = '', $groups = null); /* * Returns the violations generated by the validator so far. * * @return ConstraintViolationListInterface The constraint violation list. * * @api / public function getViolations(); /* * Returns the value at which validation was started in the object graph. * * The validator, when given an object, traverses the properties and * related objects and their properties. The root of the validation is the * object from which the traversal started. * * The current value is returned by {@link getValue}. * * @return mixed The root value of the validation. / public function getRoot(); /* * Returns the value that the validator is currently validating. * * If you want to retrieve the object that was originally passed to the * validator, use {@link getRoot}. * * @return mixed The currently validated value. / public function getValue(); /* * Returns the metadata for the currently validated value. * * With the core implementation, this method returns a * {@link Mapping\ClassMetadata} instance if the current value is an object, * a {@link Mapping\PropertyMetadata} instance if the current value is * the value of a property and a {@link Mapping\GetterMetadata} instance if * the validated value is the result of a getter method. * * If the validated value is neither of these, for example if the validator * has been called with a plain value and constraint, this method returns * null. * * @return MetadataInterface\|null The metadata of the currently validated * value. / public function getMetadata(); /* * Returns the used metadata factory. * * @return MetadataFactoryInterface The metadata factory. / public function getMetadataFactory(); /* * Returns the validation group that is currently being validated. * * @return string The current validation group. / public function getGroup(); /* * Returns the class name of the current node. * * If the metadata of the current node does not implement * {@link ClassBasedInterface} or if no metadata is available for the * current node, this method returns null. * * @return string\|null The class name or null, if no class name could be found. / public function getClassName(); /* * Returns the property name of the current node. * * If the metadata of the current node does not implement * {@link PropertyMetadataInterface} or if no metadata is available for the * current node, this method returns null. * * @return string\|null The property name or null, if no property name could be found. / public function getPropertyName(); /* * Returns the property path to the value that the validator is currently * validating. * * For example, take the following object graph: * * <pre> * (Person)---($address: Address)---($street: string) * </pre> * * When the <tt>Person</tt> instance is passed to the validator, the * property path is initially empty. When the <tt>$address</tt> property * of that person is validated, the property path is "address". When * the <tt>$street</tt> property of the related <tt>Address</tt> instance * is validated, the property path is "address.street". * * Properties of objects are prefixed with a dot in the property path. * Indices of arrays or objects implementing the {@link \ArrayAccess} * interface are enclosed in brackets. For example, if the property in * the previous example is <tt>$addresses</tt> and contains an array * of <tt>Address</tt> instance, the property path generated for the * <tt>$street</tt> property of one of these addresses is for example * "addresses[0].street". * * @param string $subPath Optional. The suffix appended to the current * property path. * * @return string The current property path. The result may be an empty * string if the validator is currently validating the * root value of the validation graph. */ public function getPropertyPath($subPath = ''); }	12.07 KB	2024-07-17 10:22
📄 GlobalExecutionContextInterface.php <?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; /* * Stores the node-independent state of a validation run. * * When the validator validates a graph of objects, it uses two classes to * store the state during the validation: * * <ul> * <li>For each node in the validation graph (objects, properties, getters) the * validator creates an instance of {@link ExecutionContextInterface} that * stores the information about that node.</li> * <li>One single <tt>GlobalExecutionContextInterface</tt> stores the state * that is independent of the current node.</li> * </ul> * * @author Bernhard Schussek <bschussek@gmail.com> / interface GlobalExecutionContextInterface { /* * Returns the violations generated by the validator so far. * * @return ConstraintViolationListInterface A list of constraint violations. / public function getViolations(); /* * Returns the value at which validation was started in the object graph. * * @return mixed The root value. * * @see ExecutionContextInterface::getRoot / public function getRoot(); /* * Returns the visitor instance used to validate the object graph nodes. * * @return ValidationVisitorInterface The validation visitor. / public function getVisitor(); /* * Returns the factory for constraint validators. * * @return ConstraintValidatorFactoryInterface The constraint validator factory. / public function getValidatorFactory(); /* * Returns the factory for validation metadata objects. * * @return MetadataFactoryInterface The metadata factory. */ public function getMetadataFactory(); }	1.89 KB	2024-07-17 10:22
📄 GroupSequenceProviderInterface.php <?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; /* * Defines the interface for a group sequence provider. / interface GroupSequenceProviderInterface { /* * Returns which validation groups should be used for a certain state * of the object. * * @return array An array of validation groups */ public function getGroupSequence(); }	597 B	2024-07-17 10:22
📁 Mapping	-	2025-05-25 12:37
📄 MetadataFactoryInterface.php <?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; /* * Returns {@link MetadataInterface} instances for values. * * @author Bernhard Schussek <bschussek@gmail.com> / interface MetadataFactoryInterface { /* * Returns the metadata for the given value. * * @param mixed $value Some value. * * @return MetadataInterface The metadata for the value. * * @throws Exception\NoSuchMetadataException If no metadata exists for the value. / public function getMetadataFor($value); /* * Returns whether metadata exists for the given value. * * @param mixed $value Some value. * * @return Boolean Whether metadata exists for the value. */ public function hasMetadataFor($value); }	990 B	2024-07-17 10:22
📄 MetadataInterface.php <?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; /* * A container for validation metadata. * * The container contains constraints that may belong to different validation * groups. Constraints for a specific group can be fetched by calling * {@link findConstraints}. * * Implement this interface to add validation metadata to your own metadata * layer. Each metadata may have named properties. Each property can be * represented by one or more {@link PropertyMetadataInterface} instances that * are returned by {@link getPropertyMetadata}. Since * <tt>PropertyMetadataInterface</tt> inherits from <tt>MetadataInterface</tt>, * each property may be divided into further properties. * * The {@link accept} method of each metadata implements the Visitor pattern. * The method should forward the call to the visitor's * {@link ValidationVisitorInterface::visit} method and additionally call * <tt>accept()</tt> on all structurally related metadata instances. * * For example, to store constraints for PHP classes and their properties, * create a class <tt>ClassMetadata</tt> (implementing <tt>MetadataInterface</tt>) * and a class <tt>PropertyMetadata</tt> (implementing <tt>PropertyMetadataInterface</tt>). * <tt>ClassMetadata::getPropertyMetadata($property)</tt> returns all * <tt>PropertyMetadata</tt> instances for a property of that class. Its * <tt>accept()</tt>-method simply forwards to <tt>ValidationVisitorInterface::visit()</tt> * and calls <tt>accept()</tt> on all contained <tt>PropertyMetadata</tt> * instances, which themselves call <tt>ValidationVisitorInterface::visit()</tt> * again. * * @author Bernhard Schussek <bschussek@gmail.com> / interface MetadataInterface { /* * Implementation of the Visitor design pattern. * * Calls {@link ValidationVisitorInterface::visit} and then forwards the * <tt>accept()</tt>-call to all property metadata instances. * * @param ValidationVisitorInterface $visitor The visitor implementing the validation logic. * @param mixed $value The value to validate. * @param string\|string[] $group The validation group to validate in. * @param string $propertyPath The current property path in the validation graph. / public function accept(ValidationVisitorInterface $visitor, $value, $group, $propertyPath); /* * Returns all constraints for a given validation group. * * @param string $group The validation group. * * @return Constraint[] A list of constraint instances. */ public function findConstraints($group); }	2.82 KB	2024-07-17 10:22
📄 ObjectInitializerInterface.php <?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; /* * Prepares an object for validation. * * Concrete implementations of this interface are used by {@link ValidationVisitorInterface} * to initialize objects just before validating them. * * @author Fabien Potencier <fabien@symfony.com> * @author Bernhard Schussek <bschussek@gmail.com> * * @api / interface ObjectInitializerInterface { /* * Initializes an object just before validation. * * @param object $object The object to validate * * @api */ public function initialize($object); }	817 B	2024-07-17 10:22
📄 PropertyMetadataContainerInterface.php <?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; /* * A container for {@link PropertyMetadataInterface} instances. * * @author Bernhard Schussek <bschussek@gmail.com> / interface PropertyMetadataContainerInterface { /* * Check if there's any metadata attached to the given named property. * * @param string $property The property name. * * @return Boolean / public function hasPropertyMetadata($property); /* * Returns all metadata instances for the given named property. * * If your implementation does not support properties, simply throw an * exception in this method (for example a <tt>BadMethodCallException</tt>). * * @param string $property The property name. * * @return PropertyMetadataInterface[] A list of metadata instances. Empty if * no metadata exists for the property. */ public function getPropertyMetadata($property); }	1.18 KB	2024-07-17 10:22
📄 PropertyMetadataInterface.php <?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; /* * A container for validation metadata of a property. * * What exactly you define as "property" is up to you. The validator expects * implementations of {@link MetadataInterface} that contain constraints and * optionally a list of named properties that also have constraints (and may * have further sub properties). Such properties are mapped by implementations * of this interface. * * @author Bernhard Schussek <bschussek@gmail.com> * * @see MetadataInterface / interface PropertyMetadataInterface extends MetadataInterface { /* * Returns the name of the property. * * @return string The property name. / public function getPropertyName(); /* * Extracts the value of the property from the given container. * * @param mixed $containingValue The container to extract the property value from. * * @return mixed The value of the property. */ public function getPropertyValue($containingValue); }	1.23 KB	2024-07-17 10:22
📁 Resources	-	2025-05-25 12:37
📄 Validation.php <?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; /* * Entry point for the Validator component. * * @author Bernhard Schussek <bschussek@gmail.com> / final class Validation { /* * Creates a new validator. * * If you want to configure the validator, use * {@link createValidatorBuilder()} instead. * * @return ValidatorInterface The new validator. / public static function createValidator() { return self::createValidatorBuilder()->getValidator(); } /* * Creates a configurable builder for validator objects. * * @return ValidatorBuilderInterface The new builder. / public static function createValidatorBuilder() { return new ValidatorBuilder(); } /* * This class cannot be instantiated. */ private function __construct() { } }	1.07 KB	2024-07-17 10:22
📄 ValidationVisitor.php <?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; use Symfony\Component\Validator\Exception\NoSuchMetadataException; use Symfony\Component\Validator\Exception\UnexpectedTypeException; use Symfony\Component\Translation\TranslatorInterface; /* * Default implementation of {@link ValidationVisitorInterface} and * {@link GlobalExecutionContextInterface}. * * @author Bernhard Schussek <bschussek@gmail.com> / class ValidationVisitor implements ValidationVisitorInterface, GlobalExecutionContextInterface { /* * @var mixed / private $root; /* * @var MetadataFactoryInterface / private $metadataFactory; /* * @var ConstraintValidatorFactoryInterface / private $validatorFactory; /* * @var TranslatorInterface / private $translator; /* * @var null\|string / private $translationDomain; /* * @var array / private $objectInitializers; /* * @var ConstraintViolationList / private $violations; /* * @var array / private $validatedObjects = array(); /* * Creates a new validation visitor. * * @param mixed $root The value passed to the validator. * @param MetadataFactoryInterface $metadataFactory The factory for obtaining metadata instances. * @param ConstraintValidatorFactoryInterface $validatorFactory The factory for creating constraint validators. * @param TranslatorInterface $translator The translator for translating violation messages. * @param string\|null $translationDomain The domain of the translation messages. * @param ObjectInitializerInterface[] $objectInitializers The initializers for preparing objects before validation. * * @throws UnexpectedTypeException If any of the object initializers is not an instance of ObjectInitializerInterface / public function __construct($root, MetadataFactoryInterface $metadataFactory, ConstraintValidatorFactoryInterface $validatorFactory, TranslatorInterface $translator, $translationDomain = null, array $objectInitializers = array()) { foreach ($objectInitializers as $initializer) { if (!$initializer instanceof ObjectInitializerInterface) { throw new UnexpectedTypeException($initializer, 'Symfony\Component\Validator\ObjectInitializerInterface'); } } $this->root = $root; $this->metadataFactory = $metadataFactory; $this->validatorFactory = $validatorFactory; $this->translator = $translator; $this->translationDomain = $translationDomain; $this->objectInitializers = $objectInitializers; $this->violations = new ConstraintViolationList(); } /* * {@inheritdoc} / public function visit(MetadataInterface $metadata, $value, $group, $propertyPath) { $context = new ExecutionContext( $this, $this->translator, $this->translationDomain, $metadata, $value, $group, $propertyPath ); $context->validateValue($value, $metadata->findConstraints($group)); } /* * {@inheritdoc} / public function validate($value, $group, $propertyPath, $traverse = false, $deep = false) { if (null === $value) { return; } if (is_object($value)) { $hash = spl_object_hash($value); // Exit, if the object is already validated for the current group if (isset($this->validatedObjects[$hash][$group])) { return; } // Remember validating this object before starting and possibly // traversing the object graph $this->validatedObjects[$hash][$group] = true; foreach ($this->objectInitializers as $initializer) { if (!$initializer instanceof ObjectInitializerInterface) { throw new \LogicException('Validator initializers must implement ObjectInitializerInterface.'); } $initializer->initialize($value); } } // Validate arrays recursively by default, otherwise every driver needs // to implement special handling for arrays. // https://github.com/symfony/symfony/issues/6246 if (is_array($value) \|\| ($traverse && $value instanceof \Traversable)) { foreach ($value as $key => $element) { // Ignore any scalar values in the collection if (is_object($element) \|\| is_array($element)) { // Only repeat the traversal if $deep is set $this->validate($element, $group, $propertyPath.'['.$key.']', $deep, $deep); } } try { $this->metadataFactory->getMetadataFor($value)->accept($this, $value, $group, $propertyPath); } catch (NoSuchMetadataException $e) { // Metadata doesn't necessarily have to exist for // traversable objects, because we know how to validate // them anyway. Optionally, additional metadata is supported. } } else { $this->metadataFactory->getMetadataFor($value)->accept($this, $value, $group, $propertyPath); } } /* * {@inheritdoc} / public function getViolations() { return $this->violations; } /* * {@inheritdoc} / public function getRoot() { return $this->root; } /* * {@inheritdoc} / public function getVisitor() { return $this; } /* * {@inheritdoc} / public function getValidatorFactory() { return $this->validatorFactory; } /* * {@inheritdoc} */ public function getMetadataFactory() { return $this->metadataFactory; } }	6.17 KB	2024-07-17 10:22
📄 ValidationVisitorInterface.php <?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; /* * Validates values against constraints defined in {@link MetadataInterface} * instances. * * This interface is an implementation of the Visitor design pattern. A value * is validated by first passing it to the {@link validate} method. That method * will determine the matching {@link MetadataInterface} for validating the * value. It then calls the {@link MetadataInterface::accept} method of that * metadata. <tt>accept()</tt> does two things: * * <ol> * <li>It calls {@link visit} to validate the value against the constraints of * the metadata.</li> * <li>It calls <tt>accept()</tt> on all nested metadata instances with the * corresponding values extracted from the current value. For example, if the * current metadata represents a class and the current value is an object of * that class, the metadata contains nested instances for each property of that * class. It forwards the call to these nested metadata with the values of the * corresponding properties in the original object.</li> * </ol> * * @author Bernhard Schussek <bschussek@gmail.com> / interface ValidationVisitorInterface { /* * Validates a value. * * If the value is an array or a traversable object, you can set the * parameter <tt>$traverse</tt> to <tt>true</tt> in order to run through * the collection and validate each element. If these elements can be * collections again and you want to traverse them recursively, set the * parameter <tt>$deep</tt> to <tt>true</tt> as well. * * If you set <tt>$traversable</tt> to <tt>true</tt>, the visitor will * nevertheless try to find metadata for the collection and validate its * constraints. If no such metadata is found, the visitor ignores that and * only iterates the collection. * * If you don't set <tt>$traversable</tt> to <tt>true</tt> and the visitor * does not find metadata for the given value, it will fail with an * exception. * * @param mixed $value The value to validate. * @param string $group The validation group to validate. * @param string $propertyPath The current property path in the validation graph. * @param Boolean $traverse Whether to traverse the value if it is traversable. * @param Boolean $deep Whether to traverse nested traversable values recursively. * * @throws Exception\NoSuchMetadataException If no metadata can be found for * the given value. / public function validate($value, $group, $propertyPath, $traverse = false, $deep = false); /* * Validates a value against the constraints defined in some metadata. * * This method implements the Visitor design pattern. See also * {@link ValidationVisitorInterface}. * * @param MetadataInterface $metadata The metadata holding the constraints. * @param mixed $value The value to validate. * @param string $group The validation group to validate. * @param string $propertyPath The current property path in the validation graph. */ public function visit(MetadataInterface $metadata, $value, $group, $propertyPath); }	3.46 KB	2024-07-17 10:22
📄 Validator.php <?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; use Symfony\Component\Validator\Constraints\Valid; use Symfony\Component\Validator\Exception\ValidatorException; use Symfony\Component\Translation\TranslatorInterface; /* * Default implementation of {@link ValidatorInterface}. * * @author Fabien Potencier <fabien@symfony.com> * @author Bernhard Schussek <bschussek@gmail.com> / class Validator implements ValidatorInterface { /* * @var MetadataFactoryInterface / private $metadataFactory; /* * @var ConstraintValidatorFactoryInterface / private $validatorFactory; /* * @var TranslatorInterface / private $translator; /* * @var null\|string / private $translationDomain; /* * @var array / private $objectInitializers; public function __construct( MetadataFactoryInterface $metadataFactory, ConstraintValidatorFactoryInterface $validatorFactory, TranslatorInterface $translator, $translationDomain = 'validators', array $objectInitializers = array() ) { $this->metadataFactory = $metadataFactory; $this->validatorFactory = $validatorFactory; $this->translator = $translator; $this->translationDomain = $translationDomain; $this->objectInitializers = $objectInitializers; } /* * {@inheritdoc} / public function getMetadataFactory() { return $this->metadataFactory; } /* * {@inheritDoc} / public function getMetadataFor($value) { return $this->metadataFactory->getMetadataFor($value); } /* * {@inheritDoc} / public function validate($value, $groups = null, $traverse = false, $deep = false) { $visitor = $this->createVisitor($value); foreach ($this->resolveGroups($groups) as $group) { $visitor->validate($value, $group, '', $traverse, $deep); } return $visitor->getViolations(); } /* * {@inheritDoc} * * @throws ValidatorException If the metadata for the value does not support properties. / public function validateProperty($containingValue, $property, $groups = null) { $visitor = $this->createVisitor($containingValue); $metadata = $this->metadataFactory->getMetadataFor($containingValue); if (!$metadata instanceof PropertyMetadataContainerInterface) { $valueAsString = is_scalar($containingValue) ? '"'.$containingValue.'"' : 'the value of type '.gettype($containingValue); throw new ValidatorException(sprintf('The metadata for %s does not support properties.', $valueAsString)); } foreach ($this->resolveGroups($groups) as $group) { if (!$metadata->hasPropertyMetadata($property)) { continue; } foreach ($metadata->getPropertyMetadata($property) as $propMeta) { $propMeta->accept($visitor, $propMeta->getPropertyValue($containingValue), $group, $property); } } return $visitor->getViolations(); } /* * {@inheritDoc} * * @throws ValidatorException If the metadata for the value does not support properties. / public function validatePropertyValue($containingValue, $property, $value, $groups = null) { $visitor = $this->createVisitor($containingValue); $metadata = $this->metadataFactory->getMetadataFor($containingValue); if (!$metadata instanceof PropertyMetadataContainerInterface) { $valueAsString = is_scalar($containingValue) ? '"'.$containingValue.'"' : 'the value of type '.gettype($containingValue); throw new ValidatorException(sprintf('The metadata for '.$valueAsString.' does not support properties.')); } foreach ($this->resolveGroups($groups) as $group) { if (!$metadata->hasPropertyMetadata($property)) { continue; } foreach ($metadata->getPropertyMetadata($property) as $propMeta) { $propMeta->accept($visitor, $value, $group, $property); } } return $visitor->getViolations(); } /* * {@inheritDoc} / public function validateValue($value, $constraints, $groups = null) { $context = new ExecutionContext($this->createVisitor($value), $this->translator, $this->translationDomain); $constraints = is_array($constraints) ? $constraints : array($constraints); foreach ($constraints as $constraint) { if ($constraint instanceof Valid) { // Why can't the Valid constraint be executed directly? // // It cannot be executed like regular other constraints, because regular // constraints are only executed if they belong to the validated group. // The Valid constraint, on the other hand, is always executed and propagates // the group to the cascaded object. The propagated group depends on // // Whether a group sequence is currently being executed. Then the default // group is propagated. // // * Otherwise the validated group is propagated. throw new ValidatorException( sprintf( 'The constraint %s cannot be validated. Use the method validate() instead.', get_class($constraint) ) ); } $context->validateValue($value, $constraint, '', $groups); } return $context->getViolations(); } /** * @param mixed $root * * @return ValidationVisitor / private function createVisitor($root) { return new ValidationVisitor( $root, $this->metadataFactory, $this->validatorFactory, $this->translator, $this->translationDomain, $this->objectInitializers ); } /* * @param null\|string\|string[] $groups * * @return string[] */ private function resolveGroups($groups) { return $groups ? (array) $groups : array(Constraint::DEFAULT_GROUP); } }	6.52 KB	2024-07-17 10:22
📄 ValidatorBuilder.php <?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; use Symfony\Component\PropertyAccess\PropertyAccess; use Symfony\Component\PropertyAccess\PropertyAccessorInterface; use Symfony\Component\Validator\Mapping\ClassMetadataFactory; use Symfony\Component\Validator\Exception\ValidatorException; use Symfony\Component\Validator\Mapping\Loader\LoaderChain; use Symfony\Component\Validator\Mapping\Cache\CacheInterface; use Symfony\Component\Validator\Mapping\Loader\StaticMethodLoader; use Symfony\Component\Validator\Mapping\Loader\YamlFileLoader; use Symfony\Component\Validator\Mapping\Loader\AnnotationLoader; use Symfony\Component\Validator\Mapping\Loader\YamlFilesLoader; use Symfony\Component\Validator\Mapping\Loader\XmlFileLoader; use Symfony\Component\Validator\Mapping\Loader\XmlFilesLoader; use Symfony\Component\Translation\TranslatorInterface; use Doctrine\Common\Annotations\Reader; use Doctrine\Common\Annotations\AnnotationReader; use Doctrine\Common\Annotations\CachedReader; use Doctrine\Common\Cache\ArrayCache; /* * The default implementation of {@link ValidatorBuilderInterface}. * * @author Bernhard Schussek <bschussek@gmail.com> / class ValidatorBuilder implements ValidatorBuilderInterface { /* * @var array / private $initializers = array(); /* * @var array / private $xmlMappings = array(); /* * @var array / private $yamlMappings = array(); /* * @var array / private $methodMappings = array(); /* * @var Reader / private $annotationReader = null; /* * @var MetadataFactoryInterface / private $metadataFactory; /* * @var ConstraintValidatorFactoryInterface / private $validatorFactory; /* * @var CacheInterface / private $metadataCache; /* * @var TranslatorInterface / private $translator; /* * @var null\|string / private $translationDomain; /* * @var PropertyAccessorInterface / private $propertyAccessor; /* * {@inheritdoc} / public function addObjectInitializer(ObjectInitializerInterface $initializer) { $this->initializers[] = $initializer; return $this; } /* * {@inheritdoc} / public function addObjectInitializers(array $initializers) { $this->initializers = array_merge($this->initializers, $initializers); return $this; } /* * {@inheritdoc} / public function addXmlMapping($path) { if (null !== $this->metadataFactory) { throw new ValidatorException('You cannot add custom mappings after setting a custom metadata factory. Configure your metadata factory instead.'); } $this->xmlMappings[] = $path; return $this; } /* * {@inheritdoc} / public function addXmlMappings(array $paths) { if (null !== $this->metadataFactory) { throw new ValidatorException('You cannot add custom mappings after setting a custom metadata factory. Configure your metadata factory instead.'); } $this->xmlMappings = array_merge($this->xmlMappings, $paths); return $this; } /* * {@inheritdoc} / public function addYamlMapping($path) { if (null !== $this->metadataFactory) { throw new ValidatorException('You cannot add custom mappings after setting a custom metadata factory. Configure your metadata factory instead.'); } $this->yamlMappings[] = $path; return $this; } /* * {@inheritdoc} / public function addYamlMappings(array $paths) { if (null !== $this->metadataFactory) { throw new ValidatorException('You cannot add custom mappings after setting a custom metadata factory. Configure your metadata factory instead.'); } $this->yamlMappings = array_merge($this->yamlMappings, $paths); return $this; } /* * {@inheritdoc} / public function addMethodMapping($methodName) { if (null !== $this->metadataFactory) { throw new ValidatorException('You cannot add custom mappings after setting a custom metadata factory. Configure your metadata factory instead.'); } $this->methodMappings[] = $methodName; return $this; } /* * {@inheritdoc} / public function addMethodMappings(array $methodNames) { if (null !== $this->metadataFactory) { throw new ValidatorException('You cannot add custom mappings after setting a custom metadata factory. Configure your metadata factory instead.'); } $this->methodMappings = array_merge($this->methodMappings, $methodNames); return $this; } /* * {@inheritdoc} / public function enableAnnotationMapping(Reader $annotationReader = null) { if (null !== $this->metadataFactory) { throw new ValidatorException('You cannot enable annotation mapping after setting a custom metadata factory. Configure your metadata factory instead.'); } if (null === $annotationReader) { if (!class_exists('Doctrine\Common\Annotations\AnnotationReader') \|\| !class_exists('Doctrine\Common\Cache\ArrayCache')) { throw new \RuntimeException('Enabling annotation based constraint mapping requires the packages doctrine/annotations and doctrine/cache to be installed.'); } $annotationReader = new CachedReader(new AnnotationReader(), new ArrayCache()); } $this->annotationReader = $annotationReader; return $this; } /* * {@inheritdoc} / public function disableAnnotationMapping() { $this->annotationReader = null; return $this; } /* * {@inheritdoc} / public function setMetadataFactory(MetadataFactoryInterface $metadataFactory) { if (count($this->xmlMappings) > 0 \|\| count($this->yamlMappings) > 0 \|\| count($this->methodMappings) > 0 \|\| null !== $this->annotationReader) { throw new ValidatorException('You cannot set a custom metadata factory after adding custom mappings. You should do either of both.'); } $this->metadataFactory = $metadataFactory; return $this; } /* * {@inheritdoc} / public function setMetadataCache(CacheInterface $cache) { if (null !== $this->metadataFactory) { throw new ValidatorException('You cannot set a custom metadata cache after setting a custom metadata factory. Configure your metadata factory instead.'); } $this->metadataCache = $cache; return $this; } /* * {@inheritdoc} / public function setConstraintValidatorFactory(ConstraintValidatorFactoryInterface $validatorFactory) { if (null !== $this->propertyAccessor) { throw new ValidatorException('You cannot set a validator factory after setting a custom property accessor. Remove the call to setPropertyAccessor() if you want to call setConstraintValidatorFactory().'); } $this->validatorFactory = $validatorFactory; return $this; } /* * {@inheritdoc} / public function setTranslator(TranslatorInterface $translator) { $this->translator = $translator; return $this; } /* * {@inheritdoc} / public function setTranslationDomain($translationDomain) { $this->translationDomain = $translationDomain; return $this; } /* * {@inheritdoc} / public function setPropertyAccessor(PropertyAccessorInterface $propertyAccessor) { if (null !== $this->validatorFactory) { throw new ValidatorException('You cannot set a property accessor after setting a custom validator factory. Configure your validator factory instead.'); } $this->propertyAccessor = $propertyAccessor; return $this; } /* * {@inheritdoc} */ public function getValidator() { $metadataFactory = $this->metadataFactory; if (!$metadataFactory) { $loaders = array(); if (count($this->xmlMappings) > 1) { $loaders[] = new XmlFilesLoader($this->xmlMappings); } elseif (1 === count($this->xmlMappings)) { $loaders[] = new XmlFileLoader($this->xmlMappings[0]); } if (count($this->yamlMappings) > 1) { $loaders[] = new YamlFilesLoader($this->yamlMappings); } elseif (1 === count($this->yamlMappings)) { $loaders[] = new YamlFileLoader($this->yamlMappings[0]); } foreach ($this->methodMappings as $methodName) { $loaders[] = new StaticMethodLoader($methodName); } if ($this->annotationReader) { $loaders[] = new AnnotationLoader($this->annotationReader); } $loader = null; if (count($loaders) > 1) { $loader = new LoaderChain($loaders); } elseif (1 === count($loaders)) { $loader = $loaders[0]; } $metadataFactory = new ClassMetadataFactory($loader, $this->metadataCache); } $propertyAccessor = $this->propertyAccessor ?: PropertyAccess::createPropertyAccessor(); $validatorFactory = $this->validatorFactory ?: new ConstraintValidatorFactory($propertyAccessor); $translator = $this->translator ?: new DefaultTranslator(); return new Validator($metadataFactory, $validatorFactory, $translator, $this->translationDomain, $this->initializers); } }	9.85 KB	2024-07-17 10:22
📄 ValidatorBuilderInterface.php <?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; use Symfony\Component\PropertyAccess\PropertyAccessorInterface; use Symfony\Component\Validator\Mapping\Cache\CacheInterface; use Symfony\Component\Translation\TranslatorInterface; use Doctrine\Common\Annotations\Reader; /* * A configurable builder for ValidatorInterface objects. * * @author Bernhard Schussek <bschussek@gmail.com> / interface ValidatorBuilderInterface { /* * Adds an object initializer to the validator. * * @param ObjectInitializerInterface $initializer The initializer. * * @return ValidatorBuilderInterface The builder object. / public function addObjectInitializer(ObjectInitializerInterface $initializer); /* * Adds a list of object initializers to the validator. * * @param array $initializers The initializer. * * @return ValidatorBuilderInterface The builder object. / public function addObjectInitializers(array $initializers); /* * Adds an XML constraint mapping file to the validator. * * @param string $path The path to the mapping file. * * @return ValidatorBuilderInterface The builder object. / public function addXmlMapping($path); /* * Adds a list of XML constraint mapping files to the validator. * * @param array $paths The paths to the mapping files. * * @return ValidatorBuilderInterface The builder object. / public function addXmlMappings(array $paths); /* * Adds a YAML constraint mapping file to the validator. * * @param string $path The path to the mapping file. * * @return ValidatorBuilderInterface The builder object. / public function addYamlMapping($path); /* * Adds a list of YAML constraint mappings file to the validator. * * @param array $paths The paths to the mapping files. * * @return ValidatorBuilderInterface The builder object. / public function addYamlMappings(array $paths); /* * Enables constraint mapping using the given static method. * * @param string $methodName The name of the method. * * @return ValidatorBuilderInterface The builder object. / public function addMethodMapping($methodName); /* * Enables constraint mapping using the given static methods. * * @param array $methodNames The names of the methods. * * @return ValidatorBuilderInterface The builder object. / public function addMethodMappings(array $methodNames); /* * Enables annotation based constraint mapping. * * @param Reader $annotationReader The annotation reader to be used. * * @return ValidatorBuilderInterface The builder object. / public function enableAnnotationMapping(Reader $annotationReader = null); /* * Disables annotation based constraint mapping. * * @return ValidatorBuilderInterface The builder object. / public function disableAnnotationMapping(); /* * Sets the class metadata factory used by the validator. * * @param MetadataFactoryInterface $metadataFactory The metadata factory. * * @return ValidatorBuilderInterface The builder object. / public function setMetadataFactory(MetadataFactoryInterface $metadataFactory); /* * Sets the cache for caching class metadata. * * @param CacheInterface $cache The cache instance. * * @return ValidatorBuilderInterface The builder object. / public function setMetadataCache(CacheInterface $cache); /* * Sets the constraint validator factory used by the validator. * * @param ConstraintValidatorFactoryInterface $validatorFactory The validator factory. * * @return ValidatorBuilderInterface The builder object. / public function setConstraintValidatorFactory(ConstraintValidatorFactoryInterface $validatorFactory); /* * Sets the translator used for translating violation messages. * * @param TranslatorInterface $translator The translator instance. * * @return ValidatorBuilderInterface The builder object. / public function setTranslator(TranslatorInterface $translator); /* * Sets the default translation domain of violation messages. * * The same message can have different translations in different domains. * Pass the domain that is used for violation messages by default to this * method. * * @param string $translationDomain The translation domain of the violation messages. * * @return ValidatorBuilderInterface The builder object. / public function setTranslationDomain($translationDomain); /* * Sets the property accessor for resolving property paths. * * @param PropertyAccessorInterface $propertyAccessor The property accessor. * * @return ValidatorBuilderInterface The builder object. / public function setPropertyAccessor(PropertyAccessorInterface $propertyAccessor); /* * Builds and returns a new validator object. * * @return ValidatorInterface The built validator. */ public function getValidator(); }	5.37 KB	2024-07-17 10:22
📄 ValidatorInterface.php <?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; /* * Validates values and graphs of objects and arrays. * * @author Bernhard Schussek <bschussek@gmail.com> * * @api / interface ValidatorInterface { /* * Validates a value. * * The accepted values depend on the {@link MetadataFactoryInterface} * implementation. * * @param mixed $value The value to validate * @param array\|null $groups The validation groups to validate. * @param Boolean $traverse Whether to traverse the value if it is traversable. * @param Boolean $deep Whether to traverse nested traversable values recursively. * * @return ConstraintViolationListInterface A list of constraint violations. If the * list is empty, validation succeeded. * * @api / public function validate($value, $groups = null, $traverse = false, $deep = false); /* * Validates a property of a value against its current value. * * The accepted values depend on the {@link MetadataFactoryInterface} * implementation. * * @param mixed $containingValue The value containing the property. * @param string $property The name of the property to validate. * @param array\|null $groups The validation groups to validate. * * @return ConstraintViolationListInterface A list of constraint violations. If the * list is empty, validation succeeded. * * @api / public function validateProperty($containingValue, $property, $groups = null); /* * Validate a property of a value against a potential value. * * The accepted values depend on the {@link MetadataFactoryInterface} * implementation. * * @param string $containingValue The value containing the property. * @param string $property The name of the property to validate * @param string $value The value to validate against the * constraints of the property. * @param array\|null $groups The validation groups to validate. * * @return ConstraintViolationListInterface A list of constraint violations. If the * list is empty, validation succeeded. * * @api / public function validatePropertyValue($containingValue, $property, $value, $groups = null); /* * Validates a value against a constraint or a list of constraints. * * @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. * * @return ConstraintViolationListInterface A list of constraint violations. If the * list is empty, validation succeeded. * * @api / public function validateValue($value, $constraints, $groups = null); /* * Returns the factory for metadata instances. * * @return MetadataFactoryInterface The metadata factory. * * @api */ public function getMetadataFactory(); }	3.5 KB	2024-07-17 10:22
📄 autoloader.php <?php spl_autoload_register(function ($class) { if ('\\' == $class[0]) { $class = substr($class, 1); } if ( 0 === strpos($class, 'Symfony\\Component\\Validator\\') && file_exists($file = __DIR__.'/../../../'.str_replace('\\', '/', $class).'.php') ) { require_once $file; } });	339 B	2024-07-17 10:22

Edit File:

Terminal