Elao\Enum\Bridge\Symfony\Validator\Constraint\Enum

Complexity

Total Complexity

15

Size/Duplication

Total Lines	100
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	3

Importance

Changes

0

<?php
//[\Attribute(\Attribute::TARGET_PROPERTY | \Attribute::TARGET_METHOD | \Attribute::IS_REPEATABLE)]
class Enum extends Choice
{
    /** @var string */
    public $class;

    /**
     * Set to true in order to validate enum values instead of instances.
     *
     * @var bool
     */
    public $asValue = false;

    public function __construct(
        $class = null,
        ?array $choices = null,
        ?bool $asValue = null,
        $callback = null,
        ?bool $multiple = null,
        ?bool $strict = null,
        ?int $min = null,
        ?int $max = null,
        ?string $message = null,
        ?string $multipleMessage = null,
        ?string $minMessage = null,
        ?string $maxMessage = null,
        $groups = null,
        $payload = null
    ) {
        parent::__construct(
            $class, // "class" is the default option here and supersedes "choices" from parent class.
            $callback,
            $multiple,
            $strict,
            $min,
            $max,
            $message,
            $multipleMessage,
            $minMessage,
            $maxMessage,
            $groups,
            $payload,
        );

This code did not parse for me. Apparently, there is an error somewhere around this line:

Syntax error, unexpected ')'

        $this->asValue = $asValue ?? $this->asValue;
        // Choices are either provided as $class argument when used as "options" (Doctrine annotations style) and handled in parent class,
        // or provided with positional or named argument using PHP construct:
        $this->choices = $choices ?? $this->choices;

        if (!is_a($this->class, EnumInterface::class, true)) {
            throw new ConstraintDefinitionException(sprintf(
                'The "class" option value must be a class FQCN implementing "%s". "%s" given.',
                EnumInterface::class,
                $this->class
            ));
        }

        // Normalize choices
        if (\is_array($this->choices)) {
            $choices = [];
            foreach ($this->choices as $choiceValue) {
                if (false === \call_user_func([$this->class, 'accepts'], $choiceValue)) {
                    throw new ConstraintDefinitionException(sprintf(
                        'Choice %s is not a valid value for enum type "%s".',
                        json_encode($choiceValue),
                        $this->class
                    ));
                }

                $choices[] = $this->asValue ? $choiceValue : \call_user_func([$this->class, 'get'], $choiceValue);
            }

            $this->choices = $choices;
        }

        // only set the callback if no choice list set
        if (!\is_array($this->choices)) {
            // Check for a user provided callback first
            if ($this->callback) {
                $this->callback = [$this->class, $this->callback];
            } else {
                $this->callback = $this->asValue ? [$this->class, 'values'] : [$this->class, 'instances'];
            }
        }
    }

    /**
     * {@inheritdoc}
     */
    public function validatedBy()
    {
        return ChoiceValidator::class;
    }

    /**
     * {@inheritdoc}
     */
    public function getDefaultOption()
    {
        return 'class';
    }