Cascader\Cascader

Complexity

Total Complexity

14

Size/Duplication

Total Lines	85
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

100%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	create()	0	9	1
A	getReflectionClass()	0	14	3
A	marshalArguments()	0	18	3
B	resolveArgument()	0	21	6
A	resolveClass()	0	7	1

<?php

declare(strict_types=1);

namespace Cascader;

use Cascader\Exception\InvalidClassException;
use Cascader\Exception\InvalidOptionsException;
use Cascader\Exception\OptionNotSetException;
use ReflectionClass;
use ReflectionParameter;

class Cascader
{
    /**
     * @param string $className
     * @param array $options
     *
     * @throws InvalidClassException
     * @throws InvalidOptionsException
     *
     * @return object
     */
    public function create(string $className, array $options)
    {
        $reflectionClass = $this->getReflectionClass($className);
        $options = Options::fromArray($options);

        $arguments = $this->marshalArguments($reflectionClass, $options);

        return new $className(...$arguments);
    }

    protected function getReflectionClass(string $className) : ReflectionClass
    {
        try {
            $reflectionClass = new ReflectionClass($className);
        } catch (\ReflectionException $ex) {
            throw InvalidClassException::forNonExistingClass($className);
        }

        if (! $reflectionClass->isInstantiable()) {
            throw InvalidClassException::forNonInstantiableClass($className);
        }

        return $reflectionClass;
    }

    protected function marshalArguments(ReflectionClass $reflectionClass, Options $options) : array
    {
        $constructor = $reflectionClass->getConstructor();

        if (null === $constructor) {
            return [];
        }

        $arguments = [];

        $constructorParameters = $constructor->getParameters();

        foreach ($constructorParameters as $parameter) {
            $arguments[] = $this->resolveArgument($parameter, $options);
        }

        return $arguments;
    }

    protected function resolveArgument(ReflectionParameter $parameter, Options $options)
    {
        try {
            $argument = $options->get($parameter->name);

            if (null !== ($parameterType = $parameter->getType())) {
                if (\is_array($argument) && ! $parameterType->isBuiltin()) {
                    list($class, $arguments) = $this->resolveClass((string)$parameterType, $argument);
                    $argument = $this->create($class, $arguments);
                }
            }

            return $argument;
        } catch (OptionNotSetException $ex) {
            if (! $parameter->isOptional()) {
                throw InvalidOptionsException::forMissingMandatoryParameter($parameter);
            }

            return $parameter->getDefaultValue();
        }
    }

    protected function resolveClass(string $class, array $arguments = []): array
    {
        $class = $arguments['__class__'] ?? $class;
        unset($arguments['__class__']);

        return [$class, $arguments];
    }
}