Yiisoft\Factory\Extractors\DefinitionExtractor

Complexity

Total Complexity

16

Size/Duplication

Total Lines	51
Duplicated Lines	0 %

Test Coverage

Coverage

86.96%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	fromCallable()	0	3	1
B	fromParameter()	0	18	10
A	fromFunction()	0	7	2
A	fromClassName()	0	8	3

<?php

declare(strict_types=1);

namespace Yiisoft\Factory\Extractors;

use Yiisoft\Factory\Definitions\DefinitionInterface;
use Yiisoft\Factory\Definitions\ClassDefinition;
use Yiisoft\Factory\Definitions\InvalidDefinition;
use Yiisoft\Factory\Definitions\ValueDefinition;
use Yiisoft\Factory\Exceptions\NotInstantiableException;

/**
 * Class DefinitionExtractor
 * This implementation resolves dependencies by using class type hints.
 * Note that service names need not match the parameter names, parameter names are ignored
 */
class DefinitionExtractor implements ExtractorInterface
{
    public function fromClassName(string $class): array
    {
        $reflectionClass = new \ReflectionClass($class);
        if (!$reflectionClass->isInstantiable()) {
            throw new NotInstantiableException($class);
        }
        $constructor = $reflectionClass->getConstructor();
        return $constructor === null ? [] : $this->fromFunction($constructor);
    }

    /**
     * @suppress PhanUndeclaredMethod
     */
    private function fromFunction(\ReflectionFunctionAbstract $reflectionFunction): array
    {
        $result = [];
        foreach ($reflectionFunction->getParameters() as $parameter) {
            $result[$parameter->getName()] = $this->fromParameter($parameter);
        }
        return $result;
    }

    /**
     * @suppress PhanUndeclaredMethod
     */
    private function fromParameter(\ReflectionParameter $parameter): DefinitionInterface
    {
        $type = $parameter->getType();
        $hasDefault = $parameter->isOptional() || $parameter->isDefaultValueAvailable() || (isset($type) && $type->allowsNull());

        if (!$hasDefault && $type === null) {
            return new InvalidDefinition();
        }

        // Our parameter has a class type hint
        if ($type !== null && !$type->isBuiltin()) {
            return new ClassDefinition($type->getName(), $type->allowsNull());
        }

        // Our parameter does not have a class type hint and either has a default value or is nullable.
        return new ValueDefinition(
            $parameter->isDefaultValueAvailable() ? $parameter->getDefaultValue() : null,
            $type !== null ? $type->getName() : null
        );
    }

    public function fromCallable(callable $callable): array
    {
        return $this->fromFunction(new \ReflectionFunction(\Closure::fromCallable($callable)));
    }
}