Innmind\Config\Structure\Prototype

Complexity

Total Complexity

16

Size/Duplication

Total Lines	112
Duplicated Lines	0 %

Test Coverage

Coverage

96.15%

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
B	process()	0	23	5
A	__construct()	0	12	1
C	build()	0	57	10

<?php
declare(strict_types = 1);

namespace Innmind\Config\Structure;

use Innmind\Config\{
    Structure,
    Structures,
    Properties,
    Property,
    Exception\OnlyOnePrototypeDefinitionAllowed,
    Exception\SchemaNotParseable,
    Exception\InvalidArgumentException,
};
use Innmind\Immutable\{
    MapInterface,
    Map,

This use statement conflicts with another class in this namespace, Innmind\Config\Structure\Map. Consider defining an alias.

    Str,
};

final class Prototype implements Structure
{
    private const PATTERN = '~^prototype<(?<type>(int|string|scalar))>\+?$~';
    private $prototype;
    private $prototypeKey;
    private $structure;
    private $structureKeys;
    private $requiresValue;

    /**
     * @param Property\Structure $prototype

The type Innmind\Config\Property\Structure was not found. Maybe you did not declare it correctly or list all dependencies?

     */
    private function __construct(
        $prototype,
        Property $prototypeKey,
        Structure $structure,
        array $structureKeys,
        bool $requiresValue
    ) {
        $this->prototype = $prototype;
        $this->prototypeKey = $prototypeKey;
        $this->structure = $structure;
        $this->structureKeys = array_flip($structureKeys);
        $this->requiresValue = $requiresValue;
    }

    public static function build(
        array $schema,
        Structures $structures,
        Properties $properties
    ): Structure {
        $prototype = $prototypeKey = null;
        $keyToRemove = null;

        foreach ($schema as $key => $value) {
            if (!is_string($key) || !Str::of($key)->matches(self::PATTERN)) {
                continue;
            }

            if (!is_null($prototype)) {
                throw new OnlyOnePrototypeDefinitionAllowed;
            }

            $prototypeKey = $properties->build(
                Str::of($key)->capture(self::PATTERN)->get('type')
            );
            $keyToRemove = $key;

            if (is_string($value)) {
                try {
                    $prototype = $properties->build(Str::of($value));
                } catch (SchemaNotParseable $e) {
                    throw new SchemaNotParseable($key, 0, $e);
                }

                continue;
            }

            if (is_array($value)) {
                try {
                    $prototype = $structures->build($value, $properties);
                } catch (SchemaNotParseable $e) {
                    throw new SchemaNotParseable($key, 0, $e);
                }

                continue;
            }

            throw new SchemaNotParseable($key);
        }

        if (is_null($prototype)) {
            throw new SchemaNotParseable;
        }

        unset($schema[$keyToRemove]);

        return new self(
            $prototype,
            $prototypeKey,
            $structures->build($schema, $properties),
            array_keys($schema),
            (string) Str::of($key)->substring(-1) === '+'

The variable $key seems to be defined by a foreach iteration on line 55. Are you sure the iterator is never empty, otherwise this variable is not defined?

        );
    }

    /**
     * {@inheritdoc}
     */
    public function process(array $data): MapInterface
    {
        $prototypes = array_diff_key($data, $this->structureKeys);

It seems like $this->structureKeys can also be of type null; however, parameter $array2 of array_diff_key() does only seem to accept array, maybe add an additional type check?

        $map = new Map('scalar', 'mixed');

        foreach ($prototypes as $key => $value) {
            try {
                $map = $map->put(
                    $this->prototypeKey->process($key),
                    $this->prototype->process($value)
                );
            } catch (InvalidArgumentException $e) {
                throw new InvalidArgumentException((string) $key, 0, $e);
            }
        }

        if ($this->requiresValue && $map->size() === 0) {
            throw new InvalidArgumentException;
        }

        return $map->merge(
            $this->structure->process(
                array_intersect_key($data, $this->structureKeys)

It seems like $this->structureKeys can also be of type null; however, parameter $array2 of array_intersect_key() does only seem to accept array, maybe add an additional type check?

            )
        );
    }
}