Innmind\Compose\Definition\Service\Argument\Pair

Complexity

Total Complexity

11

Size/Duplication

Total Lines	86
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	resolve()	0	20	1
A	references()	0	13	3
A	compile()	0	5	1
A	__construct()	0	8	3
A	fromValue()	0	17	3

<?php
declare(strict_types = 1);

namespace Innmind\Compose\Definition\Service\Argument;

use Innmind\Compose\{
    Definition\Service\Argument,
    Definition\Service\Arguments,
    Definition\Name,
    Services,
    Compilation\Service\Argument as CompiledArgument,
    Compilation\Service\Argument\Pair as CompiledPair,
    Exception\ValueNotSupported,
    Exception\LogicException,
};
use Innmind\Immutable\{
    Pair as ImmutablePair,
    StreamInterface,
    Str,
    SetInterface,
    Set,
};

final class Pair implements Argument, HoldReferences
{
    private $key;
    private $value;

    private function __construct(Argument $key, Argument $value)
    {
        if ($key instanceof Unwind || $value instanceof Unwind) {
            throw new LogicException;
        }

        $this->key = $key;
        $this->value = $value;
    }

    /**
     * {@inheritdoc}
     */
    public static function fromValue($value, Arguments $arguments): Argument
    {
        if (!is_string($value)) {
            throw new ValueNotSupported;
        }

        $value = Str::of($value);

        if (!$value->matches('~^<\S+, ?\S+>$~')) {
            throw new ValueNotSupported((string) $value);
        }

        $components = $value->capture('~^<(?<key>\S+), ?(?<value>\S+)>$~');

        return new self(
            $arguments->load((string) $components->get('key')),
            $arguments->load((string) $components->get('value'))
        );
    }

    /**
     * {@inheritdoc}
     */
    public function resolve(
        StreamInterface $built,
        Services $services
    ): StreamInterface {
        $key = $this
            ->key
            ->resolve(
                $built->clear(),
                $services
            )
            ->first();
        $value = $this
            ->value
            ->resolve(
                $built->clear(),
                $services
            )
            ->first();

        return $built->add(new ImmutablePair($key, $value));
    }

    /**
     * {@inheritdoc}
     */
    public function references(): SetInterface
    {
        $references = Set::of(Name::class);

        if ($this->key instanceof HoldReference) {
            $references = $references->add($this->key->reference());
        }

        if ($this->value instanceof HoldReference) {
            $references = $references->add($this->value->reference());
        }

        return $references;
    }

    public function compile(): CompiledArgument
    {
        return new CompiledPair(
            $this->key->compile(),
            $this->value->compile()
        );
    }
}