ServiceLocator::__construct() - Code Metrics - Inspection of "Adding connection factory and registry" - b2pweb/bdf-prime - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 7a6bdd...324ce1 )

by Sébastien
created 2020-06-12 13:37 UTC
ServiceLocator::__construct() A

↳ Parent: ServiceLocator
Complexity

Conditions	6
Paths	4
Size

Total Lines	13
Code Lines	8
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	8
CRAP Score	6.0493
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
eloc	8
c	1
b	0
f	0
dl	0
loc	13
ccs	8
cts	9
cp	0.8889
rs	9.2222
cc	6
nc	4
nop	3
crap	6.0493
<?php

namespace Bdf\Prime;

use Bdf\Prime\Connection\ConnectionInterface;

use Bdf\Prime\Entity\Hydrator\HydratorInterface;

use Bdf\Prime\Entity\Hydrator\HydratorRegistry;
use Bdf\Prime\Entity\Instantiator\InstantiatorInterface;
use Bdf\Prime\Entity\Instantiator\RegistryInstantiator;
use Bdf\Prime\Mapper\MapperFactory;
use Bdf\Prime\Repository\EntityRepository;
use Bdf\Prime\Repository\RepositoryInterface;
use Bdf\Prime\Types\TypesRegistryInterface;

use Bdf\Serializer\SerializerInterface;
use Psr\Container\ContainerInterface;

/**
 * ServiceLocator
 */
class ServiceLocator
{
    /**
     * @var ConnectionManager
     */
    private $connectionManager;

    
    /**
     * @var RepositoryInterface[]
     */
    private $repositories = [];
    
    /**
     * @var MapperFactory
     */
    private $mapperFactory;
    
    /**
     * @var SerializerInterface
     */
    private $serializer;

    /**
     * @var \Closure
     */
    private $serializerResolver;

    /**
     * @var HydratorRegistry
     */
    private $hydrators;

    /**
     * @var InstantiatorInterface
     */
    private $instantiator;

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

    /**
     * SericeLocator constructor.
     *
     * @param ConnectionManager $connectionManager
     * @param MapperFactory  $mapperFactory
     * @param InstantiatorInterface $instantiator
     */
    public function __construct(ConnectionManager $connectionManager = null, MapperFactory $mapperFactory = null, InstantiatorInterface $instantiator = null)
    {
        $this->connectionManager = $connectionManager ?: new ConnectionManager();

        $this->mapperFactory = $mapperFactory ?: new MapperFactory();

        $this->instantiator = $instantiator ?: new RegistryInstantiator();

        $this->hydrators = new HydratorRegistry();

        // TODO Legacy. Should be removed

        if ($cache = $this->connectionManager->config()->getMetadataCache()) {
        if ($cache = /** @scrutinizer ignore-deprecated */ $this->connectionManager->config()->getMetadataCache()) {
            $this->mapperFactory->setMetadataCache($cache);
        }

        if ($cache = $this->connectionManager->config()->getResultCache()) {
        if ($cache = /** @scrutinizer ignore-deprecated */ $this->connectionManager->config()->getResultCache()) {
            $this->mapperFactory->setResultCache($cache);
        }
    }

    /**
     * Returns connection manager
     *
     * @return ConnectionManager
     */
    public function connections()
    {
        return $this->connectionManager;
    }

    /**
     * Returns connection manager
     * 
     * @return MapperFactory
     */
    public function mappers()
    {
        return $this->mapperFactory;
    }
    
    /**
     * Returns connection manager config
     * 
     * @return Configuration
     *
     * @deprecated Since 1.1.

     */
    public function config()
    {
        return $this->connectionManager->config();
        return /** @scrutinizer ignore-deprecated */ $this->connectionManager->config();
    }
    
    /**
     * Get a db connection
     * 
     * @param string $name
     * 
     * @return ConnectionInterface
     */
    public function connection($name = null)
    {
        return $this->connectionManager->getConnection($name);
    }
    
    /**
     * Register a repository
     *
     * @param string $entityClass
     * @param RepositoryInterface $repository
     */
    public function registerRepository($entityClass, RepositoryInterface $repository)
    {
        $this->repositories[$entityClass] = $repository;
    }
    
    /**
     * Unregister a repository
     *
     * @param string $entityClass
     */
    public function unregisterRepository($entityClass)
    {
        if (isset($this->repositories[$entityClass]) && $this->repositories[$entityClass] instanceof EntityRepository) {
            $this->repositories[$entityClass]->destroy();
                                               destroy();
        }

        unset($this->repositories[$entityClass]);
    }
    
    /**
     * Get mapper for specified entity
     *
     * @param string|object $entityClass Name of Entity object to load mapper for
     * 
     * @return RepositoryInterface
     */
    public function repository($entityClass)
    {
        if (is_object($entityClass)) {
            $entityClass = get_class($entityClass);
        }
        
        if (!isset($this->repositories[$entityClass])) {
            $mapper = $this->mapperFactory->build($this, $entityClass);

            if ($mapper === null) {
                return null;
            }

            $this->repositories[$entityClass] = $mapper->repository();
        }
        
        return $this->repositories[$entityClass];
    }
    
    /**
     * Get repository names
     * 
     * @return array
     */
    public function repositoryNames()
    {
        return array_keys($this->repositories);
    }

    /**
     * Set the serializer
     *
     * @param \Closure|SerializerInterface $serializer
     *
     * @return $this
     */
    public function setSerializer($serializer)
    {
        if ($serializer instanceof \Closure) {
            $this->serializerResolver = $serializer;
        } elseif ($serializer instanceof SerializerInterface) {

            $this->serializer = $serializer;
        }

        return $this;
    }

    /**
     * Get the serializer
     *
     * @return SerializerInterface
     */
    public function serializer()
    {
        if ($this->serializerResolver !== null) {
            $resolver = $this->serializerResolver;
            $this->serializer = $resolver();
            $this->serializerResolver = null;
        }

        return $this->serializer;
    }

    /**
     * Get the entity hydrators registry
     *
     * @return HydratorRegistry
     */
    public function hydrators()
    {
        return $this->hydrators;
    }

    /**
     * Get the entity hydrator
     *
     * @param string|object $entity The entity class or object
     *
     * @return HydratorInterface
     */
    public function hydrator($entity)
    {
        if (is_object($entity)) {
            $entity = get_class($entity);
        }

        return $this->hydrators->get($entity);
    }

    /**
     * Get the entity instantiator
     *
     * @return InstantiatorInterface
     */
    public function instantiator()
    {
        return $this->instantiator;
    }

    /**
     * Get the types registry
     *
     * @return TypesRegistryInterface
     *
     * @deprecated Since 1.1.

     */
    public function types()
    {
        return $this->connectionManager->config()->getTypes();
        return /** @scrutinizer ignore-deprecated */ $this->connectionManager->config()->getTypes();
    }

    /**
     * DI accessor
     *
     * @return ContainerInterface
     */
    public function di()
    {
        return $this->di;
    }

    /**
     * DI accessor
     *
     * @param ContainerInterface $di
     *
     * @return $this
     */
    public function setDI(ContainerInterface $di)

    {
        $this->di = $di;

        return $this;
    }

    /**
     * Clear all cache repositories
     */
    public function clearRepositories()
    {
        foreach ($this->repositories as $repository) {
            if ($repository instanceof EntityRepository) {
                $repository->destroy();
            }
        }

        $this->repositories = [];
    }
}

b2pweb / bdf-prime

Push — master ( 7a6bdd...324ce1 )

ServiceLocator::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
