DoctrineModule\ServiceFactory\AbstractDoctrineServiceFactory

Complexity

Total Complexity

11

Size/Duplication

Total Lines	96
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	2

Test Coverage

Coverage

71.05%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	canCreate()	0	4	1
A	__invoke()	0	14	2
A	canCreateServiceWithName()	0	4	1
A	createServiceWithName()	0	4	1
B	getFactoryMapping()	0	44	6

<?php

declare(strict_types=1);

namespace DoctrineModule\ServiceFactory;

use DoctrineModule\Service\AbstractFactory;
use Interop\Container\ContainerInterface;
use Laminas\ServiceManager\AbstractFactoryInterface;
use Laminas\ServiceManager\Exception\ServiceNotFoundException;
use Laminas\ServiceManager\ServiceLocatorInterface;
use function assert;
use function preg_match;

/**
 * Abstract service factory capable of instantiating services whose names match the
 * pattern <code>doctrine.$serviceType.$serviceName</doctrine>
 *
 * @link    http://www.doctrine-project.org/
 */
class AbstractDoctrineServiceFactory implements AbstractFactoryInterface

The interface Laminas\ServiceManager\AbstractFactoryInterface has been deprecated with message: Use Laminas\ServiceManager\Factory\AbstractFactoryInterface instead.

{
    /**
     * {@inheritDoc}
     */
    public function canCreate(ContainerInterface $container, $requestedName)
    {
        return $this->getFactoryMapping($container, $requestedName) !== false;
    }

    /**
     * {@inheritDoc}
     */
    public function __invoke(ContainerInterface $container, $requestedName, ?array $options = null)
    {
        $mappings = $this->getFactoryMapping($container, $requestedName);

        if (! $mappings) {
            throw new ServiceNotFoundException();
        }

        $factoryClass = $mappings['factoryClass'];
        $factory      = new $factoryClass($mappings['serviceName']);
        assert($factory instanceof AbstractFactory);

        return $factory->createService($container);
    }

    /**
     * {@inheritDoc}
     *
     * @deprecated
     */
    public function canCreateServiceWithName(ServiceLocatorInterface $container, $name, $requestedName)
    {
        return $this->canCreate($container, $requestedName);
    }

    /**
     * {@inheritDoc}
     *
     * @deprecated
     */
    public function createServiceWithName(ServiceLocatorInterface $serviceLocator, $name, $requestedName)
    {
        return $this($serviceLocator, $requestedName);
    }

    /**
     * @return mixed[]|bool
     */
    private function getFactoryMapping(ContainerInterface $serviceLocator, string $name)
    {
        $matches = [];

        if (! preg_match(
            '/^doctrine\.((?<mappingType>orm|odm)\.|)(?<serviceType>[a-z0-9_]+)\.(?<serviceName>[a-z0-9_]+)$/',
            $name,
            $matches
        )) {
            return false;
        }

        $config      = $serviceLocator->get('config');
        $mappingType = $matches['mappingType'];
        $serviceType = $matches['serviceType'];
        $serviceName = $matches['serviceName'];

        if ($mappingType === '') {
            if (! isset($config['doctrine_factories'][$serviceType]) ||
                 ! isset($config['doctrine'][$serviceType][$serviceName])
            ) {
                return false;
            }

            return [
                'serviceType'  => $serviceType,
                'serviceName'  => $serviceName,
                'factoryClass' => $config['doctrine_factories'][$serviceType],
            ];
        }

        if (! isset(
            $config['doctrine_factories'][$mappingType][$serviceType],
            $config['doctrine'][$mappingType][$serviceType][$serviceName]
        )) {
            return false;
        }

        return [
            'serviceType'  => $serviceType,
            'serviceName'  => $serviceName,
            'factoryClass' => $config['doctrine_factories'][$mappingType][$serviceType],
        ];
    }
}