Kontrolio\Rules\ArrayNormalizer

Complexity

Total Complexity

9

Size/Duplication

Total Lines	93
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	resolveRules()	0	17	4
A	ensureType()	0	5	3
A	normalize()	0	9	1

<?php

namespace Kontrolio\Rules;

use UnexpectedValueException;

final class ArrayNormalizer
{
    private $parser;

    public function __construct(Parser $parser)
    {
        $this->parser = $parser;
    }

    /**
     * Normalizes "raw" array of rules.
     *
     * This method turns the following array structure
     *
     * [
     *     'foo' => 'equal_to:foo|not_equal_to:bar',
     *     'bar' => new EqualTo('foo'),
     *     'qux' => static function ($value) {
     *         return $value === 'qux';
     *     }
     * ]
     *
     * to this one
     *
     * [
     *    'foo' => [
     *        new EqualTo('foo'),
     *        new NotEqualTo('bar')
     *    ],
     *    'bar' => [
     *        new EqualTo('foo'),
     *    ],
     *    'qux' => [
     *        static function ($value) {
     *            return $value === 'qux';
     *        }
     *    ]
     * ]
     *
     * @param array $raw
     *
     * @return RuleInterface[]|callable[]
     * @throws UnexpectedValueException
     */
    public function normalize(array $raw)
    {
        $attributes = array_keys($raw);

        $rules = array_map(function ($attribute) use ($raw) {
            return $this->resolveRules($raw[$attribute]);
        }, $attributes);

        return array_combine($attributes, $rules);

The expression return array_combine($attributes, $rules) could also return false which is incompatible with the documented return type Kontrolio\Rules\RuleInterface[]|array<mixed,callable>. Did you maybe forget to handle an error condition?

    }

    /**
     * Resolves rules from different formats.
     *
     * @param RuleInterface[]|callable[]|RuleInterface|callable|string $rules
     *
     * @return RuleInterface[]
     * @throws UnexpectedValueException
     */
    private function resolveRules($rules)
    {
        if (is_array($rules)) {
            foreach ($rules as $rule) {
                static::ensureType($rule);
            }

            return $rules;

The expression return $rules returns an array which contains values of type callable which are incompatible with the documented value type Kontrolio\Rules\RuleInterface.

        }

        if (is_string($rules)) {
            return $this->parser->parse($rules);
        }

        static::ensureType($rules);

        return [$rules];

The expression return array($rules) returns an array which contains values of type callable which are incompatible with the documented value type Kontrolio\Rules\RuleInterface.

    }

    /**
     * Checks rule for the proper type.
     *
     * @param mixed $rule
     * @throws UnexpectedValueException
     */
    private static function ensureType($rule)
    {
        if (!$rule instanceof RuleInterface && !is_callable($rule)) {
            throw new UnexpectedValueException(
                sprintf('Rule must implement `%s` or be callable.', RuleInterface::class)
            );
        }
    }
}