Bdf\Form\Validator\ConstraintValueValidator

Complexity

Total Complexity

12

Size/Duplication

Total Lines	109
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	empty()	0	7	2
A	onTransformerException()	0	19	3
A	validate()	0	22	4
A	constraints()	0	3	1
A	hasConstraints()	0	3	1

<?php

namespace Bdf\Form\Validator;

use Bdf\Form\ElementInterface;
use Bdf\Form\Error\FormError;
use Exception;
use Symfony\Component\Validator\Constraint;

/**
 * Value validator using symfony constraint
 * The element will be used as "root" context object on the symfony validator
 *
 * @template T
 * @implements ValueValidatorInterface<T>
 */
final class ConstraintValueValidator implements ValueValidatorInterface
{
    /**
     * @var self
     */
    private static $emptyInstance;

    /**
     * @var Constraint[]
     */
    private $constraints;

    /**
     * @var TransformerExceptionConstraint
     */
    private $transformerExceptionConstraint;


    /**
     * ConstraintValueValidator constructor.
     *
     * @param Constraint[] $constraints
     * @param TransformerExceptionConstraint|null $transformerExceptionConstraint
     */
    public function __construct(array $constraints = [], ?TransformerExceptionConstraint $transformerExceptionConstraint = null)
    {
        $this->constraints = $constraints;
        $this->transformerExceptionConstraint = $transformerExceptionConstraint ?? new TransformerExceptionConstraint();
    }

    /**
     * {@inheritdoc}
     */
    public function validate($value, ElementInterface $element): FormError
    {
        if (!$this->constraints) {

The expression $this->constraints of type Symfony\Component\Validator\Constraint[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            return FormError::null();
        }

        $root = $element->root();
        $groups = $root->constraintGroups();

        /** @psalm-suppress TooManyArguments */
        // Note: Wrapping the element into a WeakReference will cause a BC break
        $context = $root->getValidator()->startContext(\WeakReference::create($element));

The call to Symfony\Component\Validator\Validator\ValidatorInterface::startContext() has too many arguments starting with WeakReference::create($element).

        foreach ($this->constraints as $constraint) {
            $errors = $context->validate($value, $constraint, $groups)->getViolations();

            if ($errors->has(0)) {
                return FormError::violation($errors->get(0));
            }
        }

        return FormError::null();
    }

    /**
     * {@inheritdoc}
     */
    public function onTransformerException(Exception $exception, $value, ElementInterface $element): FormError
    {
        if ($this->transformerExceptionConstraint->ignoreException) {
            return FormError::null();
        }

        /** @psalm-suppress TooManyArguments */
        $errors = $element->root()
            ->getValidator()
            ->startContext($element)

The call to Symfony\Component\Validator\Validator\ValidatorInterface::startContext() has too many arguments starting with $element.

            ->validate($value, $this->transformerExceptionConstraint->withException($exception))
            ->getViolations()
        ;

        if ($errors->has(0)) {
            return FormError::violation($errors->get(0));
        }

        return FormError::null();
    }

    /**
     * {@inheritdoc}
     */
    public function constraints(): array
    {
        return $this->constraints;
    }

    /**
     * {@inheritdoc}
     */
    public function hasConstraints(): bool
    {
        return !empty($this->constraints);
    }

    /**
     * Get the empty value validator instance
     *
     * @return ConstraintValueValidator<mixed>
     */
    public static function empty(): self
    {
        if (self::$emptyInstance) {
            return self::$emptyInstance;
        }

        return self::$emptyInstance = new self();
    }
}