Spiral\Attributes\Internal\Instantiator\NamedArgumentsInstantiator

Complexity

Total Complexity

13

Size/Duplication

Total Lines	110
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	instantiate()	0	18	4
A	resolveParameter()	0	28	4
A	resolveParameters()	0	18	4
A	isNamedArgumentsSupported()	0	3	1

<?php

/**
 * This file is part of Attributes package.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Spiral\Attributes\Internal\Instantiator;

use Spiral\Attributes\Internal\Exception;

/**
 * @internal NamedArgumentsInstantiator is an internal library class, please do not use it in your code.
 * @psalm-internal Spiral\Attributes
 */
final class NamedArgumentsInstantiator extends Instantiator
{
    /**
     * @var string
     */
    private const ERROR_ARGUMENT_NOT_PASSED = '%s::__construct(): Argument #%d ($%s) not passed';

    /**
     * @var string
     */
    private const ERROR_UNKNOWN_ARGUMENT = 'Unknown named parameter $%s';

    /**
     * @param \ReflectionClass $attr
     * @param array $arguments
     * @param string $context
     * @return object
     * @throws \Throwable
     */
    public function instantiate(\ReflectionClass $attr, array $arguments, string $context): object
    {
        if ($this->isNamedArgumentsSupported()) {
            try {
                return $attr->newInstanceArgs($arguments);
            } catch (\Throwable $e) {
                throw Exception::withLocation($e, $attr->getFileName(), $attr->getStartLine());
            }
        }

        $constructor = $this->getConstructor($attr);

        if ($constructor === null) {
            return $attr->newInstanceWithoutConstructor();
        }

        return $attr->newInstanceArgs(
            $this->resolveParameters($attr, $constructor, $arguments)
        );
    }

    /**
     * @return bool
     */
    private function isNamedArgumentsSupported(): bool
    {
        return \version_compare(\PHP_VERSION, '8.0') >= 0;
    }

    /**
     * @param \ReflectionClass $ctx
     * @param \ReflectionMethod $constructor
     * @param array $arguments
     * @return array
     * @throws \Throwable
     */
    private function resolveParameters(\ReflectionClass $ctx, \ReflectionMethod $constructor, array $arguments): array
    {
        $passed = [];

        try {
            foreach ($constructor->getParameters() as $parameter) {
                $passed[] = $this->resolveParameter($ctx, $parameter, $arguments);
            }

            if (\count($arguments)) {
                $message = \sprintf(self::ERROR_UNKNOWN_ARGUMENT, \array_key_first($arguments));
                throw new \BadMethodCallException($message);
            }
        } catch (\Throwable $e) {
            throw Exception::withLocation($e, $constructor->getFileName(), $constructor->getStartLine());
        }

        return $passed;
    }

    /**
     * @param \ReflectionClass $ctx
     * @param \ReflectionParameter $param
     * @param array $arguments
     * @return mixed
     * @throws \Throwable
     */
    private function resolveParameter(\ReflectionClass $ctx, \ReflectionParameter $param, array &$arguments)
    {
        switch (true) {
            case \array_key_exists($param->getName(), $arguments):
                try {
                    return $arguments[$param->getName()];
                } finally {
                    unset($arguments[$param->getName()]);
                }

            case \array_key_exists($param->getPosition(), $arguments):
                try {
                    return $arguments[$param->getPosition()];
                } finally {
                    unset($arguments[$param->getPosition()]);
                }

            case $param->isDefaultValueAvailable():
                return $param->getDefaultValue();

            default:
                $message = \vsprintf(self::ERROR_ARGUMENT_NOT_PASSED, [
                    $ctx->getName(),
                    $param->getPosition() + 1,
                    $param->getName(),
                ]);

                throw new \ArgumentCountError($message);
        }
    }
}