Smoren\Validator\Rules\Rule

Complexity

Total Complexity

12

Size/Duplication

Total Lines	88
Duplicated Lines	0 %

Test Coverage

Coverage

61.53%

Importance

Changes	1
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
B	validate()	0	30	8
A	check()	0	3	1
A	add()	0	8	2
A	nullable()	0	4	1

<?php

namespace Smoren\Validator\Rules;

use Smoren\Validator\Exceptions\CheckError;
use Smoren\Validator\Exceptions\ValidationError;
use Smoren\Validator\Interfaces\CheckInterface;
use Smoren\Validator\Interfaces\UniformRuleInterface;
use Smoren\Validator\Structs\Check;

class Rule implements UniformRuleInterface
{
    public const ERROR_NULL = 'null';

    /**
     * @var bool
     */
    protected bool $isNullable = false;

    /**
     * @var array<CheckInterface>
     */
    protected array $checks = [];
    /**
     * @var array<CheckInterface>
     */
    protected array $blockingChecks = [];

    /**
     * {@inheritDoc}
     */
    public function validate($value): void
    {
        if ($value === null) {
            if ($this->isNullable) {
                return;
            }

            throw new ValidationError($value, [[self::ERROR_NULL, []]]);
        }

        foreach ($this->blockingChecks as $check) {
            try {
                $check->execute($value);
            } catch (CheckError $e) {
                throw ValidationError::fromCheckErrors($value, [$e]);
            }
        }

        $errors = [];

        foreach ($this->checks as $check) {
            try {
                $check->execute($value);
            } catch (CheckError $e) {
                $errors[] = $e;
            }
        }

        if (\count($errors) > 0) {
            throw ValidationError::fromCheckErrors($value, $errors);
        }
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function nullable(): self
    {
        $this->isNullable = true;
        return $this;
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function add(CheckInterface $check): self
    {
        if ($check->isBlocking()) {
            $this->blockingChecks[] = $check;
        } else {
            $this->checks[] = $check;
        }
        return $this;
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function check(string $name, callable $predicate, array $params = [], bool $isBlocking = false): self
    {
        return $this->add(new Check($name, $predicate, $params, $isBlocking));
    }
}