Yiisoft\Validator\Rule\CompareHandler

Complexity

Total Complexity

17

Size/Duplication

Total Lines	102
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	5
Bugs	1	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
B	validate()	0	37	8
A	compareValues()	0	15	2
A	checkValuesAreEqual()	0	15	4
A	getTypeCastedValues()	0	5	2
A	checkFloatsEqual()	0	3	1

<?php

declare(strict_types=1);

namespace Yiisoft\Validator\Rule;

use Yiisoft\Validator\Exception\UnexpectedRuleException;
use Yiisoft\Validator\Result;
use Yiisoft\Validator\RuleHandlerInterface;
use Yiisoft\Validator\ValidationContext;

use function gettype;
use function in_array;

/**
 * Compares the specified value with another value.
 *
 * @see AbstractCompare
 * @see Equal
 * @see GreaterThan
 * @see GreaterThanOrEqual
 * @see LessThan
 * @see LessThanOrEqual
 * @see Compare
 * @see NotEqual
 */
final class CompareHandler implements RuleHandlerInterface
{
    public function validate(mixed $value, object $rule, ValidationContext $context): Result
    {
        if (!$rule instanceof AbstractCompare) {
            throw new UnexpectedRuleException(AbstractCompare::class, $rule);
        }

        $result = new Result();
        if ($value !== null && !is_scalar($value)) {
            return $result->addError($rule->getIncorrectInputMessage(), [
                'attribute' => $context->getTranslatedAttribute(),
                'type' => get_debug_type($value),
            ]);
        }

        $targetAttribute = $rule->getTargetAttribute();
        $targetValue = $rule->getTargetValue();

        if ($targetValue === null && $targetAttribute !== null) {
            /** @var mixed $targetValue */
            $targetValue = $context->getDataSet()->getAttributeValue($targetAttribute);
            if (!is_scalar($targetValue)) {
                return $result->addError($rule->getIncorrectDataSetTypeMessage(), [
                    'type' => get_debug_type($targetValue),
                ]);
            }
        }

        if ($this->compareValues($rule->getOperator(), $rule->getType(), $value, $targetValue)) {
            return $result;
        }

        return $result->addError($rule->getMessage(), [
            'attribute' => $context->getTranslatedAttribute(),
            'targetValue' => $rule->getTargetValue(),
            'targetAttribute' => $rule->getTargetAttribute(),
            'targetValueOrAttribute' => $targetValue ?? $targetAttribute,
            'value' => $value,
        ]);
    }

    /**
     * Compares two values with the specified operator.
     *
     * @param string $operator The comparison operator. One of `==`, `===`, `!=`, `!==`, `>`, `>=`, `<`, `<=`.
     * @param string $type The type of the values being compared.
     * @psalm-param CompareType::STRING | CompareType::NUMBER $type
     *
     * @param mixed $value The value being compared.
     * @param mixed $targetValue Another value being compared.
     *
     * @return bool Whether the result of comparison using the specified operator is true.
     */
    private function compareValues(string $operator, string $type, mixed $value, mixed $targetValue): bool
    {
        if (!in_array($operator, ['==', '===', '!=', '!=='])) {
            [$value, $targetValue] = $this->getTypeCastedValues($type, $value, $targetValue);
        }

        return match ($operator) {
            '==' => $this->checkValuesAreEqual($type, $value, $targetValue),
            '===' => $this->checkValuesAreEqual($type, $value, $targetValue, strict: true),
            '!=' => !$this->checkValuesAreEqual($type, $value, $targetValue),
            '!==' => !$this->checkValuesAreEqual($type, $value, $targetValue, strict: true),
            '>' => $value > $targetValue,
            '>=' => $value >= $targetValue,
            '<' => $value < $targetValue,
            '<=' => $value <= $targetValue,
        };
    }

    private function checkValuesAreEqual(
        string $type,
        mixed $value,
        mixed $targetValue,
        bool $strict = false,
    ): bool {
        if ($strict && gettype($value) !== gettype($targetValue)) {
            return false;
        }

        if ($type === CompareType::NUMBER) {
            return $this->checkFloatsEqual((float) $value, (float) $targetValue);
        }

        return (string) $value === (string) $targetValue;
    }

    private function checkFloatsEqual(float $value, float $targetValue): bool
    {
        return abs($value - $targetValue) < PHP_FLOAT_EPSILON;
    }

    /**
     * @psalm-return array{0: float, 1: float}|array{0: string, 1: string}
     */
    private function getTypeCastedValues(string $type, mixed $value, mixed $targetValue): array
    {
        return $type === CompareType::NUMBER
            ? [(float) $value, (float) $targetValue]
            : [(string) $value, (string) $targetValue];
    }
}