Smoren\Validator\Rules\FloatRule

Complexity

Total Complexity

7

Size/Duplication

Total Lines	71
Duplicated Lines	0 %

Test Coverage

Coverage

45.16%

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	nonFractional()	0	6	1
A	fractional()	0	6	1
A	finite()	0	6	2
A	infinite()	0	6	2
A	__construct()	0	9	1

<?php

declare(strict_types=1);

namespace Smoren\Validator\Rules;

use Smoren\Validator\Checks\Check;
use Smoren\Validator\Interfaces\FloatRuleInterface;
use Smoren\Validator\Structs\CheckErrorName;
use Smoren\Validator\Structs\CheckName;

class FloatRule extends NumericRule implements FloatRuleInterface
{
    protected const DEFAULT_NAME = 'float';

    /**
     * @param string $name
     */
    public function __construct(string $name)
    {
        Rule::__construct($name);
        $this->check(new Check(
            CheckName::FLOAT,
            CheckErrorName::NOT_FLOAT,
            fn ($value) => is_float($value),
            []
        ), true);
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function fractional(): self
    {
        return $this->check(new Check(
            CheckName::FRACTIONAL,
            CheckErrorName::NOT_FRACTIONAL,
            fn ($value) => \abs($value - \round($value)) >= PHP_FLOAT_EPSILON
        ));
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function nonFractional(): self
    {
        return $this->check(new Check(
            CheckName::NOT_FRACTIONAL,
            CheckErrorName::FRACTIONAL,
            fn ($value) => \abs($value - \round($value)) < PHP_FLOAT_EPSILON
        ));
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function finite(): self
    {
        return $this->check(new Check(
            CheckName::FINITE,
            CheckErrorName::NOT_FINITE,
            fn ($value) => $value > -INF && $value < INF,
        ));
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function infinite(): self
    {
        return$this->check(new Check(
            CheckName::INFINITE,
            CheckErrorName::NOT_INFINITE,
            fn ($value) => $value === -INF || $value === INF,
        ));
    }
}