Addiks\RDMBundle\DataLoader\ChoosingDataLoaderFactory

Complexity

Total Complexity

7

Size/Duplication

Total Lines	72
Duplicated Lines	0 %

Test Coverage

Coverage

72.21%

Importance

Changes	1
Bugs	0	Features	1

2 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	37	4
A	createDataLoader()	0	20	3

<?php
/**
 * Copyright (C) 2018 Gerrit Addiks.
 * This package (including this file) was released under the terms of the GPL-3.0.
 * You should have received a copy of the GNU General Public License along with this program.
 * If not, see <http://www.gnu.org/licenses/> or send me a mail so i can send you a copy.
 * @license GPL-3.0
 * @author Gerrit Addiks <gerrit@addiks.de>
 */

namespace Addiks\RDMBundle\DataLoader;

use InvalidArgumentException;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Addiks\RDMBundle\DataLoader\DataLoaderInterface;
use Addiks\RDMBundle\DataLoader\DataLoaderFactoryInterface;
use ErrorException;

/**
 * A simple data-loader-factory that chooses which data-loader to create using a parameter from the container.
 */
final class ChoosingDataLoaderFactory implements DataLoaderFactoryInterface
{

    /**
     * @var ContainerInterface
     */
    private $container;

    /**
     * @var string
     */
    private $serviceId;

    public function __construct(
        ContainerInterface $container,
        array $serviceIdMap,
        string $choosingParameterName,
        string $defaultServiceId,
        private string|null $entityManagerServiceId = null
    ) {
        if ($container->hasParameter($choosingParameterName)) {
            /** @var string $determinator */
            $determinator = $container->getParameter($choosingParameterName);

            if (!isset($serviceIdMap[$determinator])) {
                throw new InvalidArgumentException(sprintf(
                    "Invalid value '%s' for parameter '%s', allowed values are: %s",
                    $determinator,
                    $choosingParameterName,
                    implode(", ", array_keys($serviceIdMap))
                ));
            }

            $serviceId = $serviceIdMap[$determinator];

        } else {
            /** @var string $serviceId */
            $serviceId = $defaultServiceId;
        }

        # Spot errors early (this should not actually load the service)
        if (!$container->has($serviceId)) {
            throw new InvalidArgumentException(sprintf(
                "The specified service '%s' does not exist!",
                $serviceId
            ));
        }

        $this->container = $container;
        $this->serviceId = $serviceId;
    }

    public function createDataLoader(): DataLoaderInterface
    {
        /** @var object $dataLoader */
        $dataLoader = $this->container->get($this->serviceId);

        if (!$dataLoader instanceof DataLoaderInterface) {
            throw new ErrorException(sprintf(
                "Expected service with id '%s' to be of type %s!",
                $this->serviceId,
                DataLoaderInterface::class
            ));
        }
        
        if (!empty($this->entityManagerServiceId)) {
            $dataLoader->boot(function () {
                return $this->container->get($this->entityManagerServiceId);

It seems like $this->entityManagerServiceId can also be of type null; however, parameter $id of Symfony\Component\DependencyInjection\ContainerInterface::get() does only seem to accept string, maybe add an additional type check?

            });
        }

        return $dataLoader;
    }

}