Smoren\Validator\Rules\ContainerMixedRule

Complexity

Total Complexity

27

Size/Duplication

Total Lines	293
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	countable()	0	3	1
A	array()	0	3	1
A	lengthIs()	0	11	1
A	getArrayCheck()	0	5	1
A	indexedArray()	0	7	1
A	associativeArray()	0	7	1
A	object()	0	6	1
A	getHasAttributeCheck()	0	6	1
A	iterable()	0	3	1
A	arrayAccessible()	0	6	2
A	allValuesAre()	0	12	2
A	getCountableCheck()	0	5	1
A	stdObject()	0	6	1
A	empty()	0	7	1
A	instanceOf()	0	7	1
A	allKeysAre()	0	12	2
A	hasAttribute()	0	15	2
A	notEmpty()	0	7	1
A	__construct()	0	8	2
A	hasOptionalAttribute()	0	13	2
A	getIterableCheck()	0	5	1

<?php

declare(strict_types=1);

namespace Smoren\Validator\Rules;

use Smoren\Validator\Factories\CheckBuilder;
use Smoren\Validator\Helpers\ContainerAccessHelper;
use Smoren\Validator\Helpers\TypeHelper;
use Smoren\Validator\Interfaces\RuleInterface;
use Smoren\Validator\Interfaces\CheckInterface;
use Smoren\Validator\Interfaces\ContainerRuleInterface;
use Smoren\Validator\Interfaces\IntegerRuleInterface;
use Smoren\Validator\Structs\CheckName;
use Smoren\Validator\Structs\Param;

class ContainerMixedRule extends MixedRule implements ContainerRuleInterface
{
    /**
     * ContainerRule constructor.
     */
    public function __construct(string $name)
    {
        parent::__construct($name);
        $this->check(
            CheckBuilder::create(CheckName::CONTAINER)
                ->withPredicate(fn ($value) => \is_array($value) || \is_object($value))
                ->build(),
            true
        );
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function array(): self
    {
        return $this->check($this->getArrayCheck());
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function indexedArray(): self
    {
        return $this->check(
            CheckBuilder::create(CheckName::INDEXED_ARRAY)
                ->withPredicate(fn ($value) => \array_values($value) === $value)
                ->withDependOnChecks([$this->getArrayCheck()])
                ->build()
        );
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function associativeArray(): self
    {
        return $this->check(
            CheckBuilder::create(CheckName::ASSOCIATIVE_ARRAY)
                ->withPredicate(fn ($value) => \array_values($value) !== $value)
                ->withDependOnChecks([$this->getArrayCheck()])
                ->build()
        );
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function arrayAccessible(): self
    {
        return $this->check(
            CheckBuilder::create(CheckName::ARRAY_ACCESSIBLE)
                ->withPredicate(fn ($value) => \is_array($value) || $value instanceof \ArrayAccess)
                ->build()
        );
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function iterable(): self
    {
        return $this->check($this->getIterableCheck());
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function countable(): self
    {
        return $this->check($this->getCountableCheck());
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function empty(): self
    {
        return $this->check(
            CheckBuilder::create(CheckName::EMPTY)
                ->withPredicate(fn ($value) => \count($value) === 0)
                ->withDependOnChecks([$this->getCountableCheck()])
                ->build()
        );
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function notEmpty(): self
    {
        return $this->check(
            CheckBuilder::create(CheckName::NOT_EMPTY)
                ->withPredicate(fn ($value) => \count($value) > 0)
                ->withDependOnChecks([$this->getCountableCheck()])
                ->build()
        );
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function object(): self
    {
        return $this->check(
            CheckBuilder::create(CheckName::OBJECT)
                ->withPredicate(fn ($value) => \is_object($value))
                ->build()
        );
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function stdObject(): self
    {
        return $this->check(
            CheckBuilder::create(CheckName::STD_OBJECT)
                ->withPredicate(fn ($value) => $value instanceof \stdClass)
                ->build()
        );
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function instanceOf(string $class): self
    {
        return $this->check(
            CheckBuilder::create(CheckName::INSTANCE_OF)
                ->withPredicate(fn ($value) => $value instanceof $class)
                ->withCalculatedParams([Param::GIVEN_TYPE => fn ($value) => TypeHelper::getType($value)])
                ->build()
        );
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function lengthIs(IntegerRuleInterface $rule): self
    {
        return $this->check(
            CheckBuilder::create(CheckName::LENGTH_IS)
                ->withPredicate(static function ($value) use ($rule) {
                    /** @var \Countable $value */
                    $rule->validate(\count($value));
                    return true;
                })
                ->withDependOnChecks([$this->getCountableCheck()])
                ->build()
        );
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function hasAttribute(string $name, ?RuleInterface $rule = null): self
    {
        if ($rule === null) {
            return $this->check($this->getHasAttributeCheck($name));
        }

        return $this->check(
            CheckBuilder::create(CheckName::ATTRIBUTE_IS)
                ->withPredicate(static function ($value, string $name) use ($rule) {
                    $rule->validate(ContainerAccessHelper::getAttributeValue($value, $name));
                    return true;
                })
                ->withParams([Param::ATTRIBUTE => $name])
                ->withDependOnChecks([$this->getHasAttributeCheck($name)])
                ->build()
        );
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function hasOptionalAttribute(string $name, RuleInterface $rule): self
    {
        return $this->check(
            CheckBuilder::create(CheckName::HAS_ATTRIBUTE)
                ->withPredicate(static function ($value) use ($name, $rule) {
                    if (!ContainerAccessHelper::hasAccessibleAttribute($value, $name)) {
                        return true;
                    }
                    $rule->validate(ContainerAccessHelper::getAttributeValue($value, $name));
                    return true;
                })
                ->withParams([Param::ATTRIBUTE => $name])
                ->build()
        );
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function allKeysAre(RuleInterface $rule): self
    {
        return $this->check(
            CheckBuilder::create(CheckName::ALL_KEYS_ARE)
                ->withPredicate(static function ($value) use ($rule) {
                    foreach ($value as $k => $v) {
                        $rule->validate($k);
                    }
                    return true;
                })
                ->withDependOnChecks([$this->getIterableCheck()])
                ->build()
        );
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function allValuesAre(RuleInterface $rule): self
    {
        return $this->check(
            CheckBuilder::create(CheckName::ALL_VALUES_ARE)
                ->withPredicate(static function ($value) use ($rule) {
                    foreach ($value as $v) {
                        $rule->validate($v);
                    }
                    return true;
                })
                ->withDependOnChecks([$this->getIterableCheck()])
                ->build()
        );
    }

    protected function getArrayCheck(): CheckInterface
    {
        return CheckBuilder::create(CheckName::ARRAY)
            ->withPredicate(fn ($value) => \is_array($value))
            ->build();
    }

    protected function getCountableCheck(): CheckInterface
    {
        return CheckBuilder::create(CheckName::COUNTABLE)
            ->withPredicate(fn ($value) => \is_countable($value))
            ->build();
    }

    protected function getIterableCheck(): CheckInterface
    {
        return CheckBuilder::create(CheckName::ITERABLE)
            ->withPredicate(fn ($value) => \is_iterable($value))
            ->build();
    }

    protected function getHasAttributeCheck(string $name): CheckInterface
    {
        return CheckBuilder::create(CheckName::HAS_ATTRIBUTE)
            ->withPredicate(fn ($value) => ContainerAccessHelper::hasAccessibleAttribute($value, $name))
            ->withParams([Param::ATTRIBUTE => $name])
            ->build();
    }
}