samsonframework\container\collection\CollectionMethodResolver

Complexity

Total Complexity

8

Size/Duplication

Total Lines	81
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

96.55%

Importance

Changes	3
Bugs	1	Features	2

2 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
B	resolve()	0	52	7

<?php declare(strict_types = 1);
/**
 * Created by PhpStorm.
 * User: root
 * Date: 29.07.2016
 * Time: 21:38.
 */
namespace samsonframework\container\collection;

use samsonframework\container\configurator\MethodConfiguratorInterface;
use samsonframework\container\metadata\ClassMetadata;
use samsonframework\container\metadata\MethodMetadata;
use samsonframework\container\metadata\ParameterMetadata;

/**
 * Collection method resolver class.
 * @author Vitaly Iegorov <egorov@samsonos.com>
 */
class CollectionMethodResolver extends AbstractCollectionResolver implements CollectionResolverInterface
{
    /** Collection method key */
    const KEY = 'methods';

    /**
     * @var  CollectionParameterResolver Parameter resolver
     */
    protected $parameterResolver;

    /**
     * CollectionMethodResolver constructor.
     *
     * @param array $collectionConfigurators
     * @param CollectionParameterResolver $parameterResolver
     *
     * @throws \InvalidArgumentException
     */
    public function __construct(array $collectionConfigurators, CollectionParameterResolver $parameterResolver)
    {
        parent::__construct($collectionConfigurators);

        $this->parameterResolver = $parameterResolver;
    }

    /**
     * {@inheritDoc}
     */
    public function resolve(array $classDataArray, ClassMetadata $classMetadata)
    {
        // Iterate collection
        if (array_key_exists(self::KEY, $classDataArray)) {
            $reflectionClass = new \ReflectionClass($classMetadata->className);
            // Iterate configured methods
            $methodMetadata = new MethodMetadata($classMetadata);
            foreach ($classDataArray[self::KEY] as $methodName => $methodDataArray) {
                $methodReflection = $reflectionClass->getMethod($methodName);

                // Create method metadata instance
                $methodMetadata = clone $methodMetadata;
                $methodMetadata->name = $methodReflection->name;
                $methodMetadata->modifiers = $methodReflection->getModifiers();
                $methodMetadata->isPublic = $methodReflection->isPublic();

                // Check if methods inject any instances
                if (array_key_exists(CollectionParameterResolver::KEY, $methodDataArray)) {
                    /** @var \ReflectionParameter $parameter */
                    $parameterMetadata = new ParameterMetadata($methodMetadata->classMetadata, $methodMetadata);
                    // Iterate and create properties metadata form each parameter in method
                    foreach ($methodReflection->getParameters() as $parameter) {
                        $parameterMetadata = clone $parameterMetadata;
                        $parameterMetadata->name = $parameter->name;
                        $parameterMetadata->typeHint = (string)$parameter->getType();

                        // If config has such parameter
                        if (array_key_exists($parameter->name, $methodDataArray[CollectionParameterResolver::KEY])) {
                            $parameterDataArray = $methodDataArray[CollectionParameterResolver::KEY][$parameter->name];
                            // Resolve parameter
                            $this->parameterResolver->resolve($parameterDataArray, $parameterMetadata);
                        }

                        // Store parameter metadata
                        $methodMetadata->parametersMetadata[$parameterMetadata->name] = $parameterMetadata;
                        $methodMetadata->dependencies[$parameterMetadata->name] = $parameterMetadata->dependency;
                    }
                }

                // Process attributes
                foreach ($this->getAttributeConfigurator($methodDataArray) as $configurator) {
                    /** @var MethodConfiguratorInterface $configurator Parse method metadata */
                    $configurator->toMethodMetadata($methodMetadata);
                }

                // Save method metadata to class metadata
                $classMetadata->methodsMetadata[$methodMetadata->name] = $methodMetadata;
            }
        }

        return $classMetadata;
    }
}