Dgame\Ensurance\ArrayEnsurance

Complexity

Total Complexity

16

Size/Duplication

Total Lines	177
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

92.5%

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	forEach()	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

For compatibility and reusability of your code, PSR1 recommends that a file should introduce either new symbols (like classes, functions, etc.) or have side-effects (like outputting something, or including other files), but not both at the same time. The first symbol is defined on line 20 and the first side effect is on line 11.

namespace Dgame\Ensurance;

use Dgame\Type\Type;

/**
 * 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([]);
    }

    private function forEach(callable $callback): array
    {
        return array_filter(array_map($callback, $this->value));
    }

    public function all(callable $callback): self
    {
        $this->ensure(count($this->forEach($callback)) === count($this->value));

        return $this;
    }

    public function any(callable $callback): self
    {
        $this->ensure(!empty($this->forEach($callback)));

        return $this;
    }

    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.

Parameters which have default values should be placed at the end.

        return $this->all(function ($value) use ($type): bool {
            return $type->accept($value);
        });
    }

    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(function ($value) use ($type): bool {
            return $type->accept($value);
        });
    }

    /**
     * @param $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 $value
     *
     * @return ArrayEnsurance
     */
    public function hasValue($value): self
    {
        $this->ensure(in_array($value, $this->value))
             ->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;
    }
}