Smoren\Validator\Rules\ContainerRule

Complexity

Total Complexity

27

Size/Duplication

Total Lines	273
Duplicated Lines	0 %

Test Coverage

Coverage

57.55%

Importance

Changes	2
Bugs	1	Features	1

17 Methods

Rating	Name	Duplication	Size	Complexity
A	everyValueIs()	0	4	1
A	isAttribute()	0	19	3
A	arrayAccessible()	0	5	2
A	empty()	0	10	2
A	__construct()	0	7	2
A	indexedArray()	0	5	2
A	instanceOf()	0	5	1
A	notEmpty()	0	9	2
A	stdObject()	0	5	1
A	iterable()	0	5	1
A	associativeArray()	0	5	2
A	object()	0	5	1
A	array()	0	5	1
A	hasAttribute()	0	6	1
A	everyKeyIs()	0	4	1
A	countable()	0	5	1
A	lengthIs()	0	20	3

<?php

declare(strict_types=1);

namespace Smoren\Validator\Rules;

use ArrayAccess;
use Smoren\Validator\Exceptions\ValidationError;
use Smoren\Validator\Helpers\ContainerAccessHelper;
use Smoren\Validator\Interfaces\BaseRuleInterface;
use Smoren\Validator\Interfaces\ContainerRuleInterface;
use Smoren\Validator\Interfaces\IntegerRuleInterface;
use Smoren\Validator\Structs\Check;

class ContainerRule extends Rule implements ContainerRuleInterface
{
    public const ERROR_NOT_CONTAINER = 'not_container';
    public const ERROR_NOT_ARRAY = 'not_array';
    public const ERROR_NOT_INDEXED_ARRAY = 'not_array';
    public const ERROR_NOT_ASSOCIATIVE_ARRAY = 'not_array';
    public const ERROR_NOT_ITERABLE = 'not_iterable';
    public const ERROR_NOT_COUNTABLE = 'not_countable';
    public const ERROR_NOT_EMPTY = 'not_empty';
    public const ERROR_EMPTY = 'not_empty';
    public const ERROR_NOT_ARRAY_ACCESSIBLE = 'not_array_accessible';
    public const ERROR_NOT_OBJECT = 'not_object';
    public const ERROR_NOT_STD_OBJECT = 'not_std_object';
    public const ERROR_NOT_INSTANCE_OF = 'not_instance_of';
    public const ERROR_LENGTH_IS_NOT = 'length_is_not';
    public const ERROR_ATTRIBUTE_NOT_EXIST = 'attribute_not_exist';
    public const ERROR_BAD_ATTRIBUTE = 'bad_attribute';

    /**
     * ContainerRule constructor.
     */
    public function __construct()
    {
        $this->addCheck(new Check(
            self::ERROR_NOT_CONTAINER,
            fn ($value) => is_array($value) || is_object($value),
            [],
            true
        ));
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function array(): self
    {
        return $this->addCheck(new Check(
            self::ERROR_NOT_ARRAY,
            fn ($value) => is_array($value)
        ));
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function indexedArray(): self
    {
        return $this->addCheck(new Check(
            self::ERROR_NOT_INDEXED_ARRAY,
            fn ($value) => is_array($value) && (array_values($value) === $value)
        ));
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function associativeArray(): self
    {
        return $this->addCheck(new Check(
            self::ERROR_NOT_ASSOCIATIVE_ARRAY,
            fn ($value) => is_array($value) && (array_values($value) !== $value)
        ));
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function arrayAccessible(): self
    {
        return $this->addCheck(new Check(
            self::ERROR_NOT_ARRAY_ACCESSIBLE,
            fn ($value) => is_array($value) || $value instanceof ArrayAccess
        ));
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function iterable(): self
    {
        return $this->addCheck(new Check(
            self::ERROR_NOT_ITERABLE,
            fn ($value) => is_iterable($value)
        ));
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function countable(): self
    {
        return $this->addCheck(new Check(
            self::ERROR_NOT_COUNTABLE,
            fn ($value) => is_countable($value)
        ));
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function empty(): self
    {
        // TODO use AND RULE!!!
        if (!$this->isCheckNameUsed(self::ERROR_NOT_COUNTABLE)) {
            $this->countable();
        }

        return $this->addCheck(new Check(
            self::ERROR_NOT_EMPTY,
            fn ($value) => count($value) === 0
        ));
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function notEmpty(): self
    {
        if (!$this->isCheckNameUsed(self::ERROR_NOT_COUNTABLE)) {
            $this->countable();
        }

        return $this->addCheck(new Check(
            self::ERROR_EMPTY,
            fn ($value) => count($value) > 0
        ));
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function object(): self
    {
        return $this->addCheck(new Check(
            self::ERROR_NOT_OBJECT,
            fn ($value) => is_object($value)
        ));
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function stdObject(): self
    {
        return $this->addCheck(new Check(
            self::ERROR_NOT_STD_OBJECT,
            fn ($value) => $value instanceof \stdClass
        ));
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function instanceOf(string $class): self
    {
        return $this->addCheck(new Check(
            self::ERROR_NOT_INSTANCE_OF,
            fn ($value) => $value instanceof $class
        ));
    }


    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function lengthIs(IntegerRuleInterface $rule): self
    {
        if (!$this->isCheckNameUsed(self::ERROR_NOT_COUNTABLE)) {
            $this->countable();
        }

        $violations = [];
        return $this->addCheck(new Check(
            self::ERROR_LENGTH_IS_NOT,
            static function ($value) use ($rule, &$violations) {
                try {
                    /** @var \Countable $value */
                    $rule->validate(count($value));
                    return true;
                } catch (ValidationError $e) {
                    $violations = $e->getSummary();
                    return false;
                }
            },
            ['violations' => &$violations]
        ));
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function hasAttribute(string $name): self
    {
        return $this->addCheck(new Check(
            self::ERROR_ATTRIBUTE_NOT_EXIST,
            fn ($value) => ContainerAccessHelper::hasAccessibleAttribute($value, $name),
            ['name' => $name]
        ));
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function isAttribute(string $name, BaseRuleInterface $rule): self
    {
        if (!$this->isCheckNameUsed(self::ERROR_ATTRIBUTE_NOT_EXIST)) {
            $this->hasAttribute($name);
        }

        $violations = [];
        return $this->addCheck(new Check(
            self::ERROR_BAD_ATTRIBUTE,
            function ($value) use ($name, $rule, &$violations) {
                try {
                    $rule->validate(ContainerAccessHelper::getAttributeValue($value, $name));
                    return true;
                } catch (ValidationError $e) {
                    $violations = $e->getSummary();
                    return false;
                }
            },
            ['name' => $name, 'violations' => &$violations]
        ));
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function everyKeyIs(BaseRuleInterface $rule): self
    {
        // TODO: Implement everyKeyIs() method.
        return $this;
    }

    /**
     * {@inheritDoc}
     *
     * @return static
     */
    public function everyValueIs(BaseRuleInterface $rule): self
    {
        // TODO: Implement everyValueIs() method.
        return $this;
    }
}