primo commit

libraries/vendor/symfony/validator/Context/ExecutionContext.php

@@ -0,0 +1,281 @@
+<?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\Context;
+
+use Symfony\Component\Validator\Constraint;
+use Symfony\Component\Validator\ConstraintViolation;
+use Symfony\Component\Validator\ConstraintViolationList;
+use Symfony\Component\Validator\ConstraintViolationListInterface;
+use Symfony\Component\Validator\Mapping\ClassMetadataInterface;
+use Symfony\Component\Validator\Mapping\MemberMetadata;
+use Symfony\Component\Validator\Mapping\MetadataInterface;
+use Symfony\Component\Validator\Mapping\PropertyMetadataInterface;
+use Symfony\Component\Validator\Util\PropertyPath;
+use Symfony\Component\Validator\Validator\LazyProperty;
+use Symfony\Component\Validator\Validator\ValidatorInterface;
+use Symfony\Component\Validator\Violation\ConstraintViolationBuilder;
+use Symfony\Component\Validator\Violation\ConstraintViolationBuilderInterface;
+use Symfony\Contracts\Translation\TranslatorInterface;
+
+/**
+ * The context used and created by {@link ExecutionContextFactory}.
+ *
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ *
+ * @see ExecutionContextInterface
+ *
+ * @internal since version 2.5. Code against ExecutionContextInterface instead.
+ */
+class ExecutionContext implements ExecutionContextInterface
+{
+    private ValidatorInterface $validator;
+
+    /**
+     * The root value of the validated object graph.
+     */
+    private mixed $root;
+
+    private TranslatorInterface $translator;
+    private ?string $translationDomain;
+
+    /**
+     * The violations generated in the current context.
+     */
+    private ConstraintViolationList $violations;
+
+    /**
+     * The currently validated value.
+     */
+    private mixed $value = null;
+
+    /**
+     * The currently validated object.
+     */
+    private ?object $object = null;
+
+    /**
+     * The property path leading to the current value.
+     */
+    private string $propertyPath = '';
+
+    /**
+     * The current validation metadata.
+     */
+    private ?MetadataInterface $metadata = null;
+
+    /**
+     * The currently validated group.
+     */
+    private ?string $group = null;
+
+    /**
+     * The currently validated constraint.
+     */
+    private ?Constraint $constraint = null;
+
+    /**
+     * Stores which objects have been validated in which group.
+     *
+     * @var bool[][]
+     */
+    private array $validatedObjects = [];
+
+    /**
+     * Stores which class constraint has been validated for which object.
+     *
+     * @var bool[]
+     */
+    private array $validatedConstraints = [];
+
+    /**
+     * Stores which objects have been initialized.
+     *
+     * @var bool[]
+     */
+    private array $initializedObjects = [];
+
+    /**
+     * @var \SplObjectStorage<object, string>
+     */
+    private \SplObjectStorage $cachedObjectsRefs;
+
+    /**
+     * @internal Called by {@link ExecutionContextFactory}. Should not be used in user code.
+     */
+    public function __construct(ValidatorInterface $validator, mixed $root, TranslatorInterface $translator, ?string $translationDomain = null)
+    {
+        $this->validator = $validator;
+        $this->root = $root;
+        $this->translator = $translator;
+        $this->translationDomain = $translationDomain;
+        $this->violations = new ConstraintViolationList();
+        $this->cachedObjectsRefs = new \SplObjectStorage();
+    }
+
+    public function setNode(mixed $value, ?object $object, ?MetadataInterface $metadata, string $propertyPath): void
+    {
+        $this->value = $value;
+        $this->object = $object;
+        $this->metadata = $metadata;
+        $this->propertyPath = $propertyPath;
+    }
+
+    public function setGroup(?string $group): void
+    {
+        $this->group = $group;
+    }
+
+    public function setConstraint(Constraint $constraint): void
+    {
+        $this->constraint = $constraint;
+    }
+
+    public function addViolation(string|\Stringable $message, array $parameters = []): void
+    {
+        $this->violations->add(new ConstraintViolation(
+            $this->translator->trans($message, $parameters, $this->translationDomain),
+            $message,
+            $parameters,
+            $this->root,
+            $this->propertyPath,
+            $this->getValue(),
+            null,
+            null,
+            $this->constraint
+        ));
+    }
+
+    public function buildViolation(string|\Stringable $message, array $parameters = []): ConstraintViolationBuilderInterface
+    {
+        return new ConstraintViolationBuilder(
+            $this->violations,
+            $this->constraint,
+            $message,
+            $parameters,
+            $this->root,
+            $this->propertyPath,
+            $this->getValue(),
+            $this->translator,
+            $this->translationDomain
+        );
+    }
+
+    public function getViolations(): ConstraintViolationListInterface
+    {
+        return $this->violations;
+    }
+
+    public function getValidator(): ValidatorInterface
+    {
+        return $this->validator;
+    }
+
+    public function getRoot(): mixed
+    {
+        return $this->root;
+    }
+
+    public function getValue(): mixed
+    {
+        if ($this->value instanceof LazyProperty) {
+            return $this->value->getPropertyValue();
+        }
+
+        return $this->value;
+    }
+
+    public function getObject(): ?object
+    {
+        return $this->object;
+    }
+
+    public function getMetadata(): ?MetadataInterface
+    {
+        return $this->metadata;
+    }
+
+    public function getGroup(): ?string
+    {
+        return $this->group;
+    }
+
+    public function getConstraint(): ?Constraint
+    {
+        return $this->constraint;
+    }
+
+    public function getClassName(): ?string
+    {
+        return $this->metadata instanceof MemberMetadata || $this->metadata instanceof ClassMetadataInterface ? $this->metadata->getClassName() : null;
+    }
+
+    public function getPropertyName(): ?string
+    {
+        return $this->metadata instanceof PropertyMetadataInterface ? $this->metadata->getPropertyName() : null;
+    }
+
+    public function getPropertyPath(string $subPath = ''): string
+    {
+        return PropertyPath::append($this->propertyPath, $subPath);
+    }
+
+    public function markGroupAsValidated(string $cacheKey, string $groupHash): void
+    {
+        if (!isset($this->validatedObjects[$cacheKey])) {
+            $this->validatedObjects[$cacheKey] = [];
+        }
+
+        $this->validatedObjects[$cacheKey][$groupHash] = true;
+    }
+
+    public function isGroupValidated(string $cacheKey, string $groupHash): bool
+    {
+        return isset($this->validatedObjects[$cacheKey][$groupHash]);
+    }
+
+    public function markConstraintAsValidated(string $cacheKey, string $constraintHash): void
+    {
+        $this->validatedConstraints[$cacheKey.':'.$constraintHash] = true;
+    }
+
+    public function isConstraintValidated(string $cacheKey, string $constraintHash): bool
+    {
+        return isset($this->validatedConstraints[$cacheKey.':'.$constraintHash]);
+    }
+
+    public function markObjectAsInitialized(string $cacheKey): void
+    {
+        $this->initializedObjects[$cacheKey] = true;
+    }
+
+    public function isObjectInitialized(string $cacheKey): bool
+    {
+        return isset($this->initializedObjects[$cacheKey]);
+    }
+
+    /**
+     * @internal
+     */
+    public function generateCacheKey(object $object): string
+    {
+        if (!isset($this->cachedObjectsRefs[$object])) {
+            $this->cachedObjectsRefs[$object] = spl_object_hash($object);
+        }
+
+        return $this->cachedObjectsRefs[$object];
+    }
+
+    public function __clone()
+    {
+        $this->violations = clone $this->violations;
+    }
+}

libraries/vendor/symfony/validator/Context/ExecutionContextFactory.php

@@ -0,0 +1,44 @@
+<?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\Context;
+
+use Symfony\Component\Validator\Validator\ValidatorInterface;
+use Symfony\Contracts\Translation\TranslatorInterface;
+
+/**
+ * Creates new {@link ExecutionContext} instances.
+ *
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ *
+ * @internal version 2.5. Code against ExecutionContextFactoryInterface instead.
+ */
+class ExecutionContextFactory implements ExecutionContextFactoryInterface
+{
+    private TranslatorInterface $translator;
+    private ?string $translationDomain;
+
+    public function __construct(TranslatorInterface $translator, ?string $translationDomain = null)
+    {
+        $this->translator = $translator;
+        $this->translationDomain = $translationDomain;
+    }
+
+    public function createContext(ValidatorInterface $validator, mixed $root): ExecutionContextInterface
+    {
+        return new ExecutionContext(
+            $validator,
+            $root,
+            $this->translator,
+            $this->translationDomain
+        );
+    }
+}

libraries/vendor/symfony/validator/Context/ExecutionContextFactoryInterface.php

@@ -0,0 +1,33 @@
+<?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\Context;
+
+use Symfony\Component\Validator\Validator\ValidatorInterface;
+
+/**
+ * Creates instances of {@link ExecutionContextInterface}.
+ *
+ * You can use a custom factory if you want to customize the execution context
+ * that is passed through the validation run.
+ *
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ */
+interface ExecutionContextFactoryInterface
+{
+    /**
+     * Creates a new execution context.
+     *
+     * @param mixed $root The root value of the validated
+     *                    object graph
+     */
+    public function createContext(ValidatorInterface $validator, mixed $root): ExecutionContextInterface;
+}

libraries/vendor/symfony/validator/Context/ExecutionContextInterface.php

@@ -0,0 +1,297 @@
+<?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\Context;
+
+use Symfony\Component\Validator\Constraint;
+use Symfony\Component\Validator\ConstraintViolationListInterface;
+use Symfony\Component\Validator\Mapping;
+use Symfony\Component\Validator\Mapping\MetadataInterface;
+use Symfony\Component\Validator\Validator\ValidatorInterface;
+use Symfony\Component\Validator\Violation\ConstraintViolationBuilderInterface;
+
+/**
+ * The context of a validation run.
+ *
+ * The context collects all violations generated during the validation. By
+ * default, validators execute all validations in a new context:
+ *
+ *     $violations = $validator->validate($object);
+ *
+ * When you make another call to the validator, while the validation is in
+ * progress, the violations will be isolated from each other:
+ *
+ *     public function validate(mixed $value, Constraint $constraint): void
+ *     {
+ *         $validator = $this->context->getValidator();
+ *
+ *         // The violations are not added to $this->context
+ *         $violations = $validator->validate($value);
+ *     }
+ *
+ * However, if you want to add the violations to the current context, use the
+ * {@link ValidatorInterface::inContext()} method:
+ *
+ *     public function validate(mixed $value, Constraint $constraint): void
+ *     {
+ *         $validator = $this->context->getValidator();
+ *
+ *         // The violations are added to $this->context
+ *         $validator
+ *             ->inContext($this->context)
+ *             ->validate($value)
+ *         ;
+ *     }
+ *
+ * Additionally, the context provides information about the current state of
+ * the validator, such as the currently validated class, the name of the
+ * currently validated property and more. These values change over time, so you
+ * cannot store a context and expect that the methods still return the same
+ * results later on.
+ *
+ * @author Bernhard Schussek <bschussek@gmail.com>
+ */
+interface ExecutionContextInterface
+{
+    /**
+     * Adds a violation at the current node of the validation graph.
+     *
+     * @param string|\Stringable $message The error message as a string or a stringable object
+     * @param array              $params  The parameters substituted in the error message
+     *
+     * @return void
+     */
+    public function addViolation(string $message, array $params = []);
+
+    /**
+     * Returns a builder for adding a violation with extended information.
+     *
+     * Call {@link ConstraintViolationBuilderInterface::addViolation()} to
+     * add the violation when you're done with the configuration:
+     *
+     *     $context->buildViolation('Please enter a number between %min% and %max%.')
+     *         ->setParameter('%min%', '3')
+     *         ->setParameter('%max%', '10')
+     *         ->setTranslationDomain('number_validation')
+     *         ->addViolation();
+     *
+     * @param string|\Stringable $message    The error message as a string or a stringable object
+     * @param array              $parameters The parameters substituted in the error message
+     */
+    public function buildViolation(string $message, array $parameters = []): ConstraintViolationBuilderInterface;
+
+    /**
+     * Returns the validator.
+     *
+     * Useful if you want to validate additional constraints:
+     *
+     *     public function validate(mixed $value, Constraint $constraint): void
+     *     {
+     *         $validator = $this->context->getValidator();
+     *
+     *         $violations = $validator->validate($value, new Length(['min' => 3]));
+     *
+     *         if (count($violations) > 0) {
+     *             // ...
+     *         }
+     *     }
+     */
+    public function getValidator(): ValidatorInterface;
+
+    /**
+     * Returns the currently validated object.
+     *
+     * If the validator is currently validating a class constraint, the
+     * object of that class is returned. If it is validating a property or
+     * getter constraint, the object that the property/getter belongs to is
+     * returned.
+     *
+     * In other cases, null is returned.
+     */
+    public function getObject(): ?object;
+
+    /**
+     * Warning: Should not be called by user code, to be used by the validator engine only.
+     *
+     * @param object|null $object       The currently validated object
+     * @param string      $propertyPath The property path to the current value
+     *
+     * @return void
+     */
+    public function setNode(mixed $value, ?object $object, ?MetadataInterface $metadata, string $propertyPath);
+
+    /**
+     * Warning: Should not be called by user code, to be used by the validator engine only.
+     *
+     * @param string|null $group The validated group
+     *
+     * @return void
+     */
+    public function setGroup(?string $group);
+
+    /**
+     * Warning: Should not be called by user code, to be used by the validator engine only.
+     *
+     * @return void
+     */
+    public function setConstraint(Constraint $constraint);
+
+    /**
+     * Warning: Should not be called by user code, to be used by the validator engine only.
+     *
+     * @param string $cacheKey  The hash of the object
+     * @param string $groupHash The group's name or hash, if it is group
+     *                          sequence
+     *
+     * @return void
+     */
+    public function markGroupAsValidated(string $cacheKey, string $groupHash);
+
+    /**
+     * Warning: Should not be called by user code, to be used by the validator engine only.
+     *
+     * @param string $cacheKey  The hash of the object
+     * @param string $groupHash The group's name or hash, if it is group
+     *                          sequence
+     */
+    public function isGroupValidated(string $cacheKey, string $groupHash): bool;
+
+    /**
+     * Warning: Should not be called by user code, to be used by the validator engine only.
+     *
+     * @param string $cacheKey       The hash of the object
+     * @param string $constraintHash The hash of the constraint
+     *
+     * @return void
+     */
+    public function markConstraintAsValidated(string $cacheKey, string $constraintHash);
+
+    /**
+     * Warning: Should not be called by user code, to be used by the validator engine only.
+     *
+     * @param string $cacheKey       The hash of the object
+     * @param string $constraintHash The hash of the constraint
+     */
+    public function isConstraintValidated(string $cacheKey, string $constraintHash): bool;
+
+    /**
+     * Warning: Should not be called by user code, to be used by the validator engine only.
+     *
+     * @param string $cacheKey The hash of the object
+     *
+     * @see ObjectInitializerInterface
+     */
+    public function markObjectAsInitialized(string $cacheKey): void;
+
+    /**
+     * Warning: Should not be called by user code, to be used by the validator engine only.
+     *
+     * @param string $cacheKey The hash of the object
+     *
+     * @see ObjectInitializerInterface
+     */
+    public function isObjectInitialized(string $cacheKey): bool;
+
+    /**
+     * Returns the violations generated by the validator so far.
+     */
+    public function getViolations(): ConstraintViolationListInterface;
+
+    /**
+     * 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}.
+     */
+    public function getRoot(): mixed;
+
+    /**
+     * 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}.
+     */
+    public function getValue(): mixed;
+
+    /**
+     * Returns the metadata for the currently validated value.
+     *
+     * With the core implementation, this method returns a
+     * {@link Mapping\ClassMetadataInterface} 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.
+     */
+    public function getMetadata(): ?MetadataInterface;
+
+    /**
+     * Returns the validation group that is currently being validated.
+     */
+    public function getGroup(): ?string;
+
+    /**
+     * Returns the class name of the current node.
+     *
+     * If the metadata of the current node does not implement
+     * {@link Mapping\ClassMetadataInterface} or if no metadata is available for the
+     * current node, this method returns null.
+     */
+    public function getClassName(): ?string;
+
+    /**
+     * 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.
+     */
+    public function getPropertyName(): ?string;
+
+    /**
+     * 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(string $subPath = ''): string;
+}