Yarhon\RouteGuardBundle\Controller\ArgumentResolver\ServiceValueResolver

Complexity

Total Complexity

10

Size/Duplication

Total Lines	80
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	supports()	0	10	2
A	getServiceLocator()	0	15	3
A	resolve()	0	11	2
A	__construct()	0	3	1
A	transformExceptionMessage()	0	10	2

<?php

/*
 *
 * (c) Yaroslav Honcharuk <yaroslav.xs@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Yarhon\RouteGuardBundle\Controller\ArgumentResolver;

use Psr\Container\ContainerInterface;
use Symfony\Component\HttpKernel\ControllerMetadata\ArgumentMetadata;
use Symfony\Component\DependencyInjection\ServiceLocator;
use Symfony\Component\DependencyInjection\Exception\RuntimeException as ContainerRuntimeException;
use Yarhon\RouteGuardBundle\Exception\RuntimeException;

/**
 * Returns a service used as controller argument.
 *
 * @author Yaroslav Honcharuk <yaroslav.xs@gmail.com>
 * @author Nicolas Grekas <p@tchwork.com>
 */
final class ServiceValueResolver implements ArgumentValueResolverInterface
{
    private $container;

    public function __construct(ContainerInterface $container)
    {
        $this->container = $container;
    }

    /**
     * {@inheritdoc}
     */
    public function supports(ArgumentResolverContextInterface $context, ArgumentMetadata $argument)
    {
        $controller = $context->getControllerName();
        $controller = ltrim($controller, '\\');

        if (!$serviceLocator = $this->getServiceLocator($controller)) {
            return false;
        }

        return $serviceLocator->has($argument->getName());
    }

    /**
     * {@inheritdoc}
     */
    public function resolve(ArgumentResolverContextInterface $context, ArgumentMetadata $argument)
    {
        $controller = $context->getControllerName();
        $controller = ltrim($controller, '\\');
        $serviceLocator = $this->getServiceLocator($controller);

        try {
            return $serviceLocator->get($argument->getName());
        } catch (ContainerRuntimeException $e) {
            $message = $this->transformExceptionMessage($e->getMessage(), $controller, $argument->getName());
            throw new RuntimeException($message, 0, $e);
        }
    }

    /**
     * @param string $originalMessage
     * @param string $controller
     * @param string $argument
     *
     * @return string
     */
    private function transformExceptionMessage($originalMessage, $controller, $argument)
    {
        $what = sprintf('argument $%s of "%s()"', $argument, $controller);
        $message = preg_replace('/service "\.service_locator\.[^"]++"/', $what, $originalMessage);

        if ($originalMessage === $message) {
            $message = sprintf('Cannot resolve %s: %s', $what, $message);
        }

        return $message;
    }

    /**
     * @param string $controller
     *
     * @return ServiceLocator|null
     */
    private function getServiceLocator($controller)
    {
        if ($this->container->has($controller)) {
            return $this->container->get($controller);
        }

        // Before Symfony 4.1 controller service locators used class:method naming
        // See \Symfony\Component\HttpKernel\DependencyInjection\RegisterControllerArgumentLocatorsPass
        $controller = str_replace('::', ':', $controller);

        if ($this->container->has($controller)) {
            return $this->container->get($controller);
        }

        return null;
    }
}