Dgame\Ensurance\ArrayEnsurance

Complexity

Total Complexity

16

Size/Duplication

Total Lines	204
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

92.5%

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	filterBy()	0	4	1
A	all()	0	6	1
A	any()	0	6	1
A	allTypeOf()	0	8	1
A	anyTypeOf()	0	8	1
A	hasKey()	0	7	1
A	hasValue()	0	7	1
A	hasLengthOf()	0	7	1
A	isShorterThan()	0	7	1
A	isShorterOrEqualsTo()	0	7	1
A	isLongerThan()	0	7	1
A	isLongerOrEqualTo()	0	7	1
A	isAssociative()	0	8	1
A	isNotAssociative()	0	8	1
A	isCallable()	0	6	1

<?php

namespace Dgame\Ensurance;

use Dgame\Type\Type;
use Dgame\Type\TypeFactory;

/**
 * Class ArrayEnsurance
 * @package Dgame\Ensurance
 */
final class ArrayEnsurance implements EnsuranceInterface
{
    use EnsuranceTrait;

    /**
     * ArrayEnsurance constructor.
     *
     * @param EnsuranceInterface $ensurance
     */
    public function __construct(EnsuranceInterface $ensurance)
    {
        $this->transferEnsurance($ensurance);
        $this->value = $ensurance->else([]);
    }

    /**
     * @param callable $callback
     *
     * @return array
     */
    private function filterBy(callable $callback): array
    {
        return array_filter(array_map($callback, $this->value));
    }

    /**
     * @param callable $callback
     *
     * @return ArrayEnsurance
     */
    public function all(callable $callback): self
    {
        $this->ensure(count($this->filterBy($callback)) === count($this->value));

        return $this;
    }

    /**
     * @param callable $callback
     *
     * @return ArrayEnsurance
     */
    public function any(callable $callback): self
    {
        $this->ensure(!empty($this->filterBy($callback)));

        return $this;
    }

    /**
     * @param string $type
     *
     * @return ArrayEnsurance

Should the return type not be \self?

     * @throws \Exception
     */
    public function allTypeOf(string $type): self
    {
        $type = Type::import($type);

Consider using a different name than the parameter $type. This often makes code more readable.

        return $this->all(static function ($value) use ($type): bool {
            return TypeFactory::expression($value)->isSame($type);
        });
    }

    /**
     * @param string $type
     *
     * @return ArrayEnsurance

Should the return type not be \self?

     * @throws \Exception
     */
    public function anyTypeOf(string $type): self
    {
        $type = Type::import($type);

Consider using a different name than the parameter $type. This often makes code more readable.

        return $this->any(static function ($value) use ($type): bool {
            return TypeFactory::expression($value)->isSame($type);
        });
    }

    /**
     * @param mixed $key
     *
     * @return ArrayEnsurance
     */
    public function hasKey($key): self
    {
        $this->ensure(array_key_exists($key, $this->value))
             ->orThrow('Key "%s" is not contained in %s', $key, $this->value);

        return $this;
    }

    /**
     * @param mixed $value
     *
     * @return ArrayEnsurance
     */
    public function hasValue($value): self
    {
        $this->ensure(in_array($value, $this->value, true))
             ->orThrow('Value "%s" is not contained in ', $value, $this->value);

        return $this;
    }

    /**
     * @param int $length
     *
     * @return ArrayEnsurance
     */
    public function hasLengthOf(int $length): self
    {
        $count = count($this->value);
        $this->ensure($count === $length)->orThrow('array has not the length %d (%d)', $length, $count);

        return $this;
    }

    /**
     * @param int $length
     *
     * @return ArrayEnsurance
     */
    public function isShorterThan(int $length): self
    {
        $count = count($this->value);
        $this->ensure($count < $length)->orThrow('array is not shorter than %d (%d)', $length, $count);

        return $this;
    }

    /**
     * @param int $length
     *
     * @return ArrayEnsurance
     */
    public function isShorterOrEqualsTo(int $length): self
    {
        $count = count($this->value);
        $this->ensure($count <= $length)->orThrow('array is not shorter or equal to %d (%d)', $length, $count);

        return $this;
    }

    /**
     * @param int $length
     *
     * @return ArrayEnsurance
     */
    public function isLongerThan(int $length): self
    {
        $count = count($this->value);
        $this->ensure($count > $length)->orThrow('array is longer than %d (%d)', $length, $count);

        return $this;
    }

    /**
     * @param int $length
     *
     * @return ArrayEnsurance
     */
    public function isLongerOrEqualTo(int $length): self
    {
        $count = count($this->value);
        $this->ensure($count >= $length)->orThrow('array is not longer or equal to %d (%d)', $length, $count);

        return $this;
    }

    /**
     * @return ArrayEnsurance
     */
    public function isAssociative(): self
    {
        $count = count($this->value);
        $this->ensure(array_keys($this->value) !== range(0, $count - 1))
             ->orThrow('array %s is not associative', $this->value);

        return $this;
    }

    /**
     * @return ArrayEnsurance
     */
    public function isNotAssociative(): self
    {
        $count = count($this->value);
        $this->ensure(array_keys($this->value) === range(0, $count - 1))
             ->orThrow('array %s is associative', $this->value);

        return $this;
    }

    /**
     * @return ArrayEnsurance
     */
    public function isCallable(): self
    {
        $this->ensure(is_callable($this->value))->orThrow('Value is not a callable');

        return $this;
    }
}