RelationalBuilder::getCacheDriver() - Code Metrics - Inspection of "add custom types mapping to doctrine's types" - juliangut/doctrine-manager-builder - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 7f63d4...d30d0e )

by Julián

created 2017-10-08 11:19 UTC

RelationalBuilder::getCacheDriver() A

↳ Parent: RelationalBuilder

Complexity

Conditions	3
Paths	4

Size

Total Lines	13
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	13
rs	9.4285
c	0
b	0
f	0
cc	3
eloc	7
nc	4
nop	2

<?php

/*
 * doctrine-manager-builder (https://github.com/juliangut/doctrine-manager-builder).
 * Doctrine2 managers builder.
 *
 * @license BSD-3-Clause
 * @link https://github.com/juliangut/doctrine-manager-builder
 * @author Julián Gutiérrez <[email protected]>
 */

namespace Jgut\Doctrine\ManagerBuilder;

use Doctrine\Common\Annotations\AnnotationReader;
use Doctrine\Common\Cache\CacheProvider;
use Doctrine\DBAL\Logging\SQLLogger;
use Doctrine\DBAL\Tools\Console\Helper\ConnectionHelper;
use Doctrine\DBAL\Types\Type;
use Doctrine\ORM\Cache\CacheConfiguration;
use Doctrine\ORM\Configuration;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\EntityRepository;
use Doctrine\ORM\Mapping\DefaultQuoteStrategy;
use Doctrine\ORM\Mapping\Driver\AnnotationDriver;
use Doctrine\ORM\Mapping\Driver\XmlDriver;
use Doctrine\ORM\Mapping\Driver\YamlDriver;
use Doctrine\ORM\Mapping\NamingStrategy;
use Doctrine\ORM\Mapping\QuoteStrategy;
use Doctrine\ORM\Mapping\UnderscoreNamingStrategy;
use Doctrine\ORM\Repository\RepositoryFactory;
use Doctrine\ORM\Tools\Console\Helper\EntityManagerHelper;
use Doctrine\ORM\Version;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Helper\HelperSet;

/**
 * Doctrine RDBMS Entity Manager builder.
 *
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 * @SuppressWarnings(PHPMD.ExcessiveClassComplexity)
 */
class RelationalBuilder extends AbstractManagerBuilder
{
    /**
     * Query cache driver.
     *
     * @var CacheProvider
     */
    protected $queryCacheDriver;

    /**
     * Result cache driver.
     *
     * @var CacheProvider
     */
    protected $resultCacheDriver;

    /**
     * Hydrator cache driver.
     *
     * @var CacheProvider
     */
    protected $hydratorCacheDriver;

    /**
     * Naming strategy.
     *
     * @var NamingStrategy
     */
    protected $namingStrategy;

    /**
     * Quote strategy.
     *
     * @var QuoteStrategy
     */
    protected $quoteStrategy;

    /**
     * Second level cache configuration.
     *
     * @var CacheConfiguration
     */
    protected $secondCacheConfig;

    /**
     * SQL logger.
     *
     * @var SQLLogger
     */
    protected $SQLLogger;

    /**
     * {@inheritdoc}
     */
    protected function getDefaultOptions()
    {
        return [
            'connection' => [], // Array or \Doctrine\DBAL\Connection
            'proxies_namespace' => 'DoctrineRDBMSORMProxy',
            'metadata_cache_namespace' => 'DoctrineRDBMSORMMetadataCache',
            'query_cache_namespace' => 'DoctrineRDBMSORMQueryCache',
            'result_cache_namespace' => 'DoctrineRDBMSORMResultCache',
            'hydrator_cache_namespace' => 'DoctrineRDBMSORMHydratorCache',
            'default_repository_class' => EntityRepository::class,
            'second_level_cache_enable' => false,
        ];
    }

    /**
     * {@inheritdoc}
     */
    protected function wipe()
    {
        $this->manager = null;
        $this->mappingDriver = null;
        $this->metadataCacheDriver = null;
        $this->eventManager = null;
        $this->queryCacheDriver = null;
        $this->resultCacheDriver = null;
        $this->namingStrategy = null;
        $this->quoteStrategy = null;
        $this->SQLLogger = null;
    }

    /**
     * {@inheritdoc}
     *
     * @throws \Doctrine\DBAL\DBALException
     * @throws \Doctrine\ORM\ORMException
     * @throws \InvalidArgumentException
     * @throws \RuntimeException
     * @throws \UnexpectedValueException
     *
     * @return EntityManager
     */
    protected function buildManager()
    {
        $config = new Configuration();

        $this->setUpGeneralConfigurations($config);
        $this->setUpSpecificConfigurations($config);

        $eventManager = $this->getEventManager();
        if ($this->getEventSubscribers() !== null) {
            /* @var array $eventSubscribers */
            $eventSubscribers = $this->getEventSubscribers();

            foreach ($eventSubscribers as $eventSubscriber) {
                $eventManager->addEventSubscriber($eventSubscriber);
            }
        }

        $entityManager = EntityManager::create($this->getOption('connection'), $config, $eventManager);

        $customMappingTypes = $this->getCustomMappingTypes();

        $platform = $entityManager->getConnection()->getDatabasePlatform();
        foreach ($this->getCustomTypes() as $type => $class) {
            if (Type::hasType($type)) {
                Type::overrideType($type, $class);
            } else {
                Type::addType($type, $class);
            }

            $platform->registerDoctrineTypeMapping(
                $type,
                array_key_exists($type, $customMappingTypes) ? $customMappingTypes[$type] : $type
            );
        }

        return $entityManager;
    }

    /**
     * Set up general manager configurations.
     *
     * @param Configuration $config
     */
    protected function setUpGeneralConfigurations(Configuration $config)
    {
        $this->setupAnnotationMetadata();
        $config->setMetadataDriverImpl($this->getMetadataMappingDriver());

        $config->setProxyDir($this->getProxiesPath());
        $config->setProxyNamespace($this->getProxiesNamespace());
        $config->setAutoGenerateProxyClasses($this->getProxiesAutoGeneration());

        if ($this->getRepositoryFactory() !== null) {
            $config->setRepositoryFactory($this->getRepositoryFactory());
        }

        if ($this->getDefaultRepositoryClass() !== null) {
            $config->setDefaultRepositoryClassName($this->getDefaultRepositoryClass());
        }

        $config->setMetadataCacheImpl($this->getMetadataCacheDriver());
    }

    /**
     * Set up manager specific configurations.
     *
     * @param Configuration $config
     */
    protected function setUpSpecificConfigurations(Configuration $config)
    {
        $config->setQueryCacheImpl($this->getQueryCacheDriver());
        $config->setResultCacheImpl($this->getResultCacheDriver());
        $config->setHydrationCacheImpl($this->getHydratorCacheDriver());

        $config->setNamingStrategy($this->getNamingStrategy());
        $config->setQuoteStrategy($this->getQuoteStrategy());

        if ($this->getSecondLevelCacheConfiguration() !== null) {
            $config->setSecondLevelCacheEnabled(true);
            $config->setSecondLevelCacheConfiguration($this->getSecondLevelCacheConfiguration());
        }

        $config->setSQLLogger($this->getSQLLogger());
        $config->setCustomStringFunctions($this->getCustomStringFunctions());
        $config->setCustomNumericFunctions($this->getCustomNumericFunctions());
        $config->setCustomDatetimeFunctions($this->getCustomDateTimeFunctions());

        foreach ($this->getCustomFilters() as $name => $filterClass) {
            $config->addFilter($name, $filterClass);
        }
    }

    /**
     * {@inheritdoc}
     */
    protected function getAnnotationMappingDriver(array $paths)
    {
        return new AnnotationDriver(new AnnotationReader, $paths);
    }

    /**
     * {@inheritdoc}
     */
    protected function getXmlMappingDriver(array $paths, $extension = null)
    {
        $extension = $extension ?: XmlDriver::DEFAULT_FILE_EXTENSION;

        return new XmlDriver($paths, $extension);
    }

    /**
     * {@inheritdoc}
     */
    protected function getYamlMappingDriver(array $paths, $extension = null)
    {
        $extension = $extension ?: YamlDriver::DEFAULT_FILE_EXTENSION;

        return new YamlDriver($paths, $extension);
    }

    /**
     * {@inheritdoc}
     *
     * @throws \InvalidArgumentException
     *
     * @return RepositoryFactory|null
     */
    protected function getRepositoryFactory()
    {
        if (!array_key_exists('repository_factory', $this->options)) {
            return;
        }

        $repositoryFactory = $this->options['repository_factory'];

        if (!$repositoryFactory instanceof RepositoryFactory) {
            throw new \InvalidArgumentException(sprintf(
                'Invalid factory class "%s". It must be a Doctrine\ORM\Repository\RepositoryFactory.',
                get_class($repositoryFactory)
            ));
        }

        return $repositoryFactory;
    }

    /**
     * Retrieve query cache driver.
     *
     * @throws \InvalidArgumentException
     *
     * @return CacheProvider
     */
    public function getQueryCacheDriver()
    {
        if (!$this->queryCacheDriver instanceof CacheProvider) {
            $this->queryCacheDriver = $this->getCacheDriver(
                (string) $this->getOption('query_cache_namespace'),
                $this->getOption('query_cache_driver')
            );
        }

        return $this->queryCacheDriver;
    }

    /**
     * Set query cache driver.
     *
     * @param CacheProvider $queryCacheDriver
     */
    public function setQueryCacheDriver(CacheProvider $queryCacheDriver)
    {
        $this->queryCacheDriver = $queryCacheDriver;
    }

    /**
     * Retrieve result cache driver.
     *
     * @throws \InvalidArgumentException
     *
     * @return CacheProvider
     */
    public function getResultCacheDriver()
    {
        if (!$this->resultCacheDriver instanceof CacheProvider) {
            $this->resultCacheDriver = $this->getCacheDriver(
                (string) $this->getOption('result_cache_namespace'),
                $this->getOption('result_cache_driver')
            );
        }

        return $this->resultCacheDriver;
    }

    /**
     * Set result cache driver.
     *
     * @param CacheProvider $resultCacheDriver
     */
    public function setResultCacheDriver(CacheProvider $resultCacheDriver)
    {
        $this->resultCacheDriver = $resultCacheDriver;
    }

    /**
     * Retrieve hydrator cache driver.
     *
     * @throws \InvalidArgumentException
     *
     * @return CacheProvider
     */
    public function getHydratorCacheDriver()
    {
        if (!$this->hydratorCacheDriver instanceof CacheProvider) {
            $this->hydratorCacheDriver = $this->getCacheDriver(
                (string) $this->getOption('hydrator_cache_namespace'),
                $this->getOption('hydrator_cache_driver')
            );
        }

        return $this->hydratorCacheDriver;
    }

    /**
     * Set hydrator cache driver.
     *
     * @param CacheProvider $hydratorCacheDriver
     */
    public function setHydratorCacheDriver(CacheProvider $hydratorCacheDriver)
    {
        $this->hydratorCacheDriver = $hydratorCacheDriver;
    }

    /**
     * Get cache driver.
     *
     * @param string             $cacheNamespace
     * @param CacheProvider|null $cacheDriver
     *
     * @return CacheProvider
     */
    protected function getCacheDriver($cacheNamespace, CacheProvider $cacheDriver = null)
    {
        if (!$cacheDriver instanceof CacheProvider) {
            $cacheDriver = clone $this->getMetadataCacheDriver();
            $cacheDriver->setNamespace($cacheNamespace);
        }

        if ($cacheDriver->getNamespace() === '') {
            $cacheDriver->setNamespace($cacheNamespace);
        }

        return $cacheDriver;
    }

    /**
     * Retrieve naming strategy.
     *
     * @return NamingStrategy
     */
    protected function getNamingStrategy()
    {
        if (!$this->namingStrategy instanceof NamingStrategy) {
            $namingStrategy = $this->getOption('naming_strategy');

            if (!$namingStrategy instanceof NamingStrategy) {
                $namingStrategy = new UnderscoreNamingStrategy(CASE_LOWER);
            }

            $this->namingStrategy = $namingStrategy;
        }

        return $this->namingStrategy;
    }

    /**
     * Retrieve quote strategy.
     *
     * @throws \InvalidArgumentException
     *
     * @return QuoteStrategy
     */
    protected function getQuoteStrategy()
    {
        if (!$this->quoteStrategy instanceof QuoteStrategy) {
            $quoteStrategy = $this->getOption('quote_strategy');

            if (!$quoteStrategy instanceof QuoteStrategy) {
                $quoteStrategy = new DefaultQuoteStrategy;
            }

            $this->quoteStrategy = $quoteStrategy;
        }

        return $this->quoteStrategy;
    }

    /**
     * Retrieve second level cache configuration.
     *
     * @return CacheConfiguration|null
     */
    protected function getSecondLevelCacheConfiguration()
    {
        if (!$this->secondCacheConfig instanceof CacheConfiguration) {
            $secondCacheConfig = $this->getOption('second_level_cache_configuration');

            if ($secondCacheConfig instanceof CacheConfiguration) {
                $this->secondCacheConfig = $secondCacheConfig;
            }
        }

        return $this->secondCacheConfig;
    }

    /**
     * Retrieve SQL logger.
     *
     * @return SQLLogger|null
     */
    protected function getSQLLogger()
    {
        if (!$this->SQLLogger instanceof SQLLogger) {
            $sqlLogger = $this->getOption('sql_logger');

            if ($sqlLogger instanceof SQLLogger) {
                $this->SQLLogger = $sqlLogger;
            }
        }

        return $this->SQLLogger;
    }

    /**
     * Retrieve custom DQL string functions.
     *
     * @return array
     */
    protected function getCustomStringFunctions()
    {
        $functions = (array) $this->getOption('custom_string_functions');

        return array_filter(
            $functions,
            function ($name) {
                return is_string($name);
            },
            ARRAY_FILTER_USE_KEY
        );
    }

    /**
     * Retrieve custom DQL numeric functions.
     *
     * @return array
     */
    protected function getCustomNumericFunctions()
    {
        $functions = (array) $this->getOption('custom_numeric_functions');

        return array_filter(
            $functions,
            function ($name) {
                return is_string($name);
            },
            ARRAY_FILTER_USE_KEY
        );
    }

    /**
     * Retrieve custom DQL date time functions.
     *
     * @return array
     */
    protected function getCustomDateTimeFunctions()
    {
        $functions = (array) $this->getOption('custom_datetime_functions');

        return array_filter(
            $functions,
            function ($name) {
                return is_string($name);
            },
            ARRAY_FILTER_USE_KEY
        );
    }

    /**
     * Retrieve custom DBAL types.
     *
     * @return array
     */
    protected function getCustomTypes()
    {
        $types = (array) $this->getOption('custom_types');

        return array_filter(
            $types,
            function ($name) {
                return is_string($name);
            },
            ARRAY_FILTER_USE_KEY
        );
    }

    /**
     * Retrieve custom DBAL mapping types.
     *
     * @return array
     */
    protected function getCustomMappingTypes()
    {
        $mappingTypes = (array) $this->getOption('custom_mapping_types');

        return array_filter(
            $mappingTypes,
            function ($name) {
                return is_string($name);
            },
            ARRAY_FILTER_USE_KEY
        );
    }

    /**
     * Get custom registered filters.
     *
     * @return array
     */
    protected function getCustomFilters()
    {
        $filters = (array) $this->getOption('custom_filters');

        return array_filter(
            $filters,
            function ($name) {
                return is_string($name);
            },
            ARRAY_FILTER_USE_KEY
        );
    }

    /**
     * {@inheritdoc}
     *
     * @throws \Doctrine\DBAL\DBALException
     * @throws \Doctrine\ORM\ORMException
     * @throws \InvalidArgumentException
     * @throws \RuntimeException
     * @throws \Symfony\Component\Console\Exception\InvalidArgumentException
     * @throws \Symfony\Component\Console\Exception\LogicException
     * @throws \UnexpectedValueException
     *
     * @return Command[]
     */
    public function getConsoleCommands()
    {
        $commands = [
            // DBAL
            new \Doctrine\DBAL\Tools\Console\Command\RunSqlCommand(),
            new \Doctrine\DBAL\Tools\Console\Command\ImportCommand(),

            // ORM
            new \Doctrine\ORM\Tools\Console\Command\ClearCache\MetadataCommand(),
            new \Doctrine\ORM\Tools\Console\Command\ClearCache\ResultCommand(),
            new \Doctrine\ORM\Tools\Console\Command\ClearCache\QueryCommand(),
            new \Doctrine\ORM\Tools\Console\Command\SchemaTool\CreateCommand(),
            new \Doctrine\ORM\Tools\Console\Command\SchemaTool\UpdateCommand(),
            new \Doctrine\ORM\Tools\Console\Command\SchemaTool\DropCommand(),
            new \Doctrine\ORM\Tools\Console\Command\EnsureProductionSettingsCommand(),
            new \Doctrine\ORM\Tools\Console\Command\ConvertDoctrine1SchemaCommand(),
            new \Doctrine\ORM\Tools\Console\Command\GenerateRepositoriesCommand(),
            new \Doctrine\ORM\Tools\Console\Command\GenerateEntitiesCommand(),
            new \Doctrine\ORM\Tools\Console\Command\GenerateProxiesCommand(),
            new \Doctrine\ORM\Tools\Console\Command\ConvertMappingCommand(),
            new \Doctrine\ORM\Tools\Console\Command\RunDqlCommand(),
            new \Doctrine\ORM\Tools\Console\Command\ValidateSchemaCommand(),
            new \Doctrine\ORM\Tools\Console\Command\InfoCommand(),
        ];

        if (Version::compare('2.5') <= 0) {
            $commands[] = new \Doctrine\ORM\Tools\Console\Command\MappingDescribeCommand();
        }

        $helperSet = $this->getConsoleHelperSet();
        $commandPrefix = (string) $this->getName();

        $commands = array_map(
            function (Command $command) use ($helperSet, $commandPrefix) {
                if ($commandPrefix !== '') {
                    $commandNames = array_map(
                        function ($commandName) use ($commandPrefix) {
                            return preg_replace('/^(dbal|orm):/', '$1:' . $commandPrefix . ':', $commandName);
                        },
                        array_merge([$command->getName()], $command->getAliases())
                    );

                    $command->setName(array_shift($commandNames));
                    $command->setAliases($commandNames);
                }

                $command->setHelperSet($helperSet);

                return $command;
            },
            $commands
        );

        return $commands;
    }

    /**
     * Get console helper set.
     *
     * @return \Symfony\Component\Console\Helper\HelperSet
     */
    protected function getConsoleHelperSet()
    {
        /* @var EntityManager $entityManager */
        $entityManager = $this->getManager();

        return new HelperSet([
            'db' => new ConnectionHelper($entityManager->getConnection()),
            'em' => new EntityManagerHelper($entityManager),
        ]);
    }
}


1			<?php
2
3			/*
4			* doctrine-manager-builder (https://github.com/juliangut/doctrine-manager-builder).
5			* Doctrine2 managers builder.
6			*
7			* @license BSD-3-Clause
8			* @link https://github.com/juliangut/doctrine-manager-builder
9			* @author Julián Gutiérrez <[email protected]>
10			*/
11
12			namespace Jgut\Doctrine\ManagerBuilder;
13
14			use Doctrine\Common\Annotations\AnnotationReader;
15			use Doctrine\Common\Cache\CacheProvider;
16			use Doctrine\DBAL\Logging\SQLLogger;
17			use Doctrine\DBAL\Tools\Console\Helper\ConnectionHelper;
18			use Doctrine\DBAL\Types\Type;
19			use Doctrine\ORM\Cache\CacheConfiguration;
20			use Doctrine\ORM\Configuration;
21			use Doctrine\ORM\EntityManager;
22			use Doctrine\ORM\EntityRepository;
23			use Doctrine\ORM\Mapping\DefaultQuoteStrategy;
24			use Doctrine\ORM\Mapping\Driver\AnnotationDriver;
25			use Doctrine\ORM\Mapping\Driver\XmlDriver;
26			use Doctrine\ORM\Mapping\Driver\YamlDriver;
27			use Doctrine\ORM\Mapping\NamingStrategy;
28			use Doctrine\ORM\Mapping\QuoteStrategy;
29			use Doctrine\ORM\Mapping\UnderscoreNamingStrategy;
30			use Doctrine\ORM\Repository\RepositoryFactory;
31			use Doctrine\ORM\Tools\Console\Helper\EntityManagerHelper;
32			use Doctrine\ORM\Version;
33			use Symfony\Component\Console\Command\Command;
34			use Symfony\Component\Console\Helper\HelperSet;
35
36			/**
37			* Doctrine RDBMS Entity Manager builder.
38			*
39			* @SuppressWarnings(PHPMD.CouplingBetweenObjects)
40			* @SuppressWarnings(PHPMD.ExcessiveClassComplexity)
41			*/
42			class RelationalBuilder extends AbstractManagerBuilder
43			{
44			/**
45			* Query cache driver.
46			*
47			* @var CacheProvider
48			*/
49			protected $queryCacheDriver;
50
51			/**
52			* Result cache driver.
53			*
54			* @var CacheProvider
55			*/
56			protected $resultCacheDriver;
57
58			/**
59			* Hydrator cache driver.
60			*
61			* @var CacheProvider
62			*/
63			protected $hydratorCacheDriver;
64
65			/**
66			* Naming strategy.
67			*
68			* @var NamingStrategy
69			*/
70			protected $namingStrategy;
71
72			/**
73			* Quote strategy.
74			*
75			* @var QuoteStrategy
76			*/
77			protected $quoteStrategy;
78
79			/**
80			* Second level cache configuration.
81			*
82			* @var CacheConfiguration
83			*/
84			protected $secondCacheConfig;
85
86			/**
87			* SQL logger.
88			*
89			* @var SQLLogger
90			*/
91			protected $SQLLogger;
92
93			/**
94			* {@inheritdoc}
95			*/
96			protected function getDefaultOptions()
97			{
98			return [
99			'connection' => [], // Array or \Doctrine\DBAL\Connection
100			'proxies_namespace' => 'DoctrineRDBMSORMProxy',
101			'metadata_cache_namespace' => 'DoctrineRDBMSORMMetadataCache',
102			'query_cache_namespace' => 'DoctrineRDBMSORMQueryCache',
103			'result_cache_namespace' => 'DoctrineRDBMSORMResultCache',
104			'hydrator_cache_namespace' => 'DoctrineRDBMSORMHydratorCache',
105			'default_repository_class' => EntityRepository::class,
106			'second_level_cache_enable' => false,
107			];
108			}
109
110			/**
111			* {@inheritdoc}
112			*/
113			protected function wipe()
114			{
115			$this->manager = null;
116			$this->mappingDriver = null;
117			$this->metadataCacheDriver = null;
118			$this->eventManager = null;
119			$this->queryCacheDriver = null;
120			$this->resultCacheDriver = null;
121			$this->namingStrategy = null;
122			$this->quoteStrategy = null;
123			$this->SQLLogger = null;
124			}
125
126			/**
127			* {@inheritdoc}
128			*
129			* @throws \Doctrine\DBAL\DBALException
130			* @throws \Doctrine\ORM\ORMException
131			* @throws \InvalidArgumentException
132			* @throws \RuntimeException
133			* @throws \UnexpectedValueException
134			*
135			* @return EntityManager
136			*/
137			protected function buildManager()
138			{
139			$config = new Configuration();
140
141			$this->setUpGeneralConfigurations($config);
142			$this->setUpSpecificConfigurations($config);
143
144			$eventManager = $this->getEventManager();
145			if ($this->getEventSubscribers() !== null) {
146			/* @var array $eventSubscribers */
147			$eventSubscribers = $this->getEventSubscribers();
148
149			foreach ($eventSubscribers as $eventSubscriber) {
150			$eventManager->addEventSubscriber($eventSubscriber);
151			}
152			}
153
154			$entityManager = EntityManager::create($this->getOption('connection'), $config, $eventManager);
155
156			$customMappingTypes = $this->getCustomMappingTypes();
157
158			$platform = $entityManager->getConnection()->getDatabasePlatform();
159			foreach ($this->getCustomTypes() as $type => $class) {
160			if (Type::hasType($type)) {
161			Type::overrideType($type, $class);
162			} else {
163			Type::addType($type, $class);
164			}
165
166			$platform->registerDoctrineTypeMapping(
167			$type,
168			array_key_exists($type, $customMappingTypes) ? $customMappingTypes[$type] : $type
169			);
170			}
171
172			return $entityManager;
173			}
174
175			/**
176			* Set up general manager configurations.
177			*
178			* @param Configuration $config
179			*/
180			protected function setUpGeneralConfigurations(Configuration $config)
181			{
182			$this->setupAnnotationMetadata();
183			$config->setMetadataDriverImpl($this->getMetadataMappingDriver());
184
185			$config->setProxyDir($this->getProxiesPath());
186			$config->setProxyNamespace($this->getProxiesNamespace());
187			$config->setAutoGenerateProxyClasses($this->getProxiesAutoGeneration());
188
189			if ($this->getRepositoryFactory() !== null) {
190			$config->setRepositoryFactory($this->getRepositoryFactory());
191			}
192
193			if ($this->getDefaultRepositoryClass() !== null) {
194			$config->setDefaultRepositoryClassName($this->getDefaultRepositoryClass());
195			}
196
197			$config->setMetadataCacheImpl($this->getMetadataCacheDriver());
198			}
199
200			/**
201			* Set up manager specific configurations.
202			*
203			* @param Configuration $config
204			*/
205			protected function setUpSpecificConfigurations(Configuration $config)
206			{
207			$config->setQueryCacheImpl($this->getQueryCacheDriver());
208			$config->setResultCacheImpl($this->getResultCacheDriver());
209			$config->setHydrationCacheImpl($this->getHydratorCacheDriver());
210
211			$config->setNamingStrategy($this->getNamingStrategy());
212			$config->setQuoteStrategy($this->getQuoteStrategy());
213
214			if ($this->getSecondLevelCacheConfiguration() !== null) {
215			$config->setSecondLevelCacheEnabled(true);
216			$config->setSecondLevelCacheConfiguration($this->getSecondLevelCacheConfiguration());
217			}
218
219			$config->setSQLLogger($this->getSQLLogger());
220			$config->setCustomStringFunctions($this->getCustomStringFunctions());
221			$config->setCustomNumericFunctions($this->getCustomNumericFunctions());
222			$config->setCustomDatetimeFunctions($this->getCustomDateTimeFunctions());
223
224			foreach ($this->getCustomFilters() as $name => $filterClass) {
225			$config->addFilter($name, $filterClass);
226			}
227			}
228
229			/**
230			* {@inheritdoc}
231			*/
232			protected function getAnnotationMappingDriver(array $paths)
233			{
234			return new AnnotationDriver(new AnnotationReader, $paths);
235			}
236
237			/**
238			* {@inheritdoc}
239			*/
240			protected function getXmlMappingDriver(array $paths, $extension = null)
241			{
242			$extension = $extension ?: XmlDriver::DEFAULT_FILE_EXTENSION;
243
244			return new XmlDriver($paths, $extension);
245			}
246
247			/**
248			* {@inheritdoc}
249			*/
250			protected function getYamlMappingDriver(array $paths, $extension = null)
251			{
252			$extension = $extension ?: YamlDriver::DEFAULT_FILE_EXTENSION;
253
254			return new YamlDriver($paths, $extension);
255			}
256
257			/**
258			* {@inheritdoc}
259			*
260			* @throws \InvalidArgumentException
261			*
262			* @return RepositoryFactory\|null
263			*/
264			protected function getRepositoryFactory()
265			{
266			if (!array_key_exists('repository_factory', $this->options)) {
267			return;
268			}
269
270			$repositoryFactory = $this->options['repository_factory'];
271
272			if (!$repositoryFactory instanceof RepositoryFactory) {
273			throw new \InvalidArgumentException(sprintf(
274			'Invalid factory class "%s". It must be a Doctrine\ORM\Repository\RepositoryFactory.',
275			get_class($repositoryFactory)
276			));
277			}
278
279			return $repositoryFactory;
280			}
281
282			/**
283			* Retrieve query cache driver.
284			*
285			* @throws \InvalidArgumentException
286			*
287			* @return CacheProvider
288			*/
289			public function getQueryCacheDriver()
290			{
291			if (!$this->queryCacheDriver instanceof CacheProvider) {
292			$this->queryCacheDriver = $this->getCacheDriver(
293			(string) $this->getOption('query_cache_namespace'),
294			$this->getOption('query_cache_driver')
295			);
296			}
297
298			return $this->queryCacheDriver;
299			}
300
301			/**
302			* Set query cache driver.
303			*
304			* @param CacheProvider $queryCacheDriver
305			*/
306			public function setQueryCacheDriver(CacheProvider $queryCacheDriver)
307			{
308			$this->queryCacheDriver = $queryCacheDriver;
309			}
310
311			/**
312			* Retrieve result cache driver.
313			*
314			* @throws \InvalidArgumentException
315			*
316			* @return CacheProvider
317			*/
318			public function getResultCacheDriver()
319			{
320			if (!$this->resultCacheDriver instanceof CacheProvider) {
321			$this->resultCacheDriver = $this->getCacheDriver(
322			(string) $this->getOption('result_cache_namespace'),
323			$this->getOption('result_cache_driver')
324			);
325			}
326
327			return $this->resultCacheDriver;
328			}
329
330			/**
331			* Set result cache driver.
332			*
333			* @param CacheProvider $resultCacheDriver
334			*/
335			public function setResultCacheDriver(CacheProvider $resultCacheDriver)
336			{
337			$this->resultCacheDriver = $resultCacheDriver;
338			}
339
340			/**
341			* Retrieve hydrator cache driver.
342			*
343			* @throws \InvalidArgumentException
344			*
345			* @return CacheProvider
346			*/
347			public function getHydratorCacheDriver()
348			{
349			if (!$this->hydratorCacheDriver instanceof CacheProvider) {
350			$this->hydratorCacheDriver = $this->getCacheDriver(
351			(string) $this->getOption('hydrator_cache_namespace'),
352			$this->getOption('hydrator_cache_driver')
353			);
354			}
355
356			return $this->hydratorCacheDriver;
357			}
358
359			/**
360			* Set hydrator cache driver.
361			*
362			* @param CacheProvider $hydratorCacheDriver
363			*/
364			public function setHydratorCacheDriver(CacheProvider $hydratorCacheDriver)
365			{
366			$this->hydratorCacheDriver = $hydratorCacheDriver;
367			}
368
369			/**
370			* Get cache driver.
371			*
372			* @param string $cacheNamespace
373			* @param CacheProvider\|null $cacheDriver
374			*
375			* @return CacheProvider
376			*/
377			protected function getCacheDriver($cacheNamespace, CacheProvider $cacheDriver = null)
378			{
379			if (!$cacheDriver instanceof CacheProvider) {
380			$cacheDriver = clone $this->getMetadataCacheDriver();
381			$cacheDriver->setNamespace($cacheNamespace);
382			}
383
384			if ($cacheDriver->getNamespace() === '') {
385			$cacheDriver->setNamespace($cacheNamespace);
386			}
387
388			return $cacheDriver;
389			}
390
391			/**
392			* Retrieve naming strategy.
393			*
394			* @return NamingStrategy
395			*/
396			protected function getNamingStrategy()
397			{
398			if (!$this->namingStrategy instanceof NamingStrategy) {
399			$namingStrategy = $this->getOption('naming_strategy');
400
401			if (!$namingStrategy instanceof NamingStrategy) {
402			$namingStrategy = new UnderscoreNamingStrategy(CASE_LOWER);
403			}
404
405			$this->namingStrategy = $namingStrategy;
406			}
407
408			return $this->namingStrategy;
409			}
410
411			/**
412			* Retrieve quote strategy.
413			*
414			* @throws \InvalidArgumentException
415			*
416			* @return QuoteStrategy
417			*/
418			protected function getQuoteStrategy()
419			{
420			if (!$this->quoteStrategy instanceof QuoteStrategy) {
421			$quoteStrategy = $this->getOption('quote_strategy');
422
423			if (!$quoteStrategy instanceof QuoteStrategy) {
424			$quoteStrategy = new DefaultQuoteStrategy;
425			}
426
427			$this->quoteStrategy = $quoteStrategy;
428			}
429
430			return $this->quoteStrategy;
431			}
432
433			/**
434			* Retrieve second level cache configuration.
435			*
436			* @return CacheConfiguration\|null
437			*/
438			protected function getSecondLevelCacheConfiguration()
439			{
440			if (!$this->secondCacheConfig instanceof CacheConfiguration) {
441			$secondCacheConfig = $this->getOption('second_level_cache_configuration');
442
443			if ($secondCacheConfig instanceof CacheConfiguration) {
444			$this->secondCacheConfig = $secondCacheConfig;
445			}
446			}
447
448			return $this->secondCacheConfig;
449			}
450
451			/**
452			* Retrieve SQL logger.
453			*
454			* @return SQLLogger\|null
455			*/
456			protected function getSQLLogger()
457			{
458			if (!$this->SQLLogger instanceof SQLLogger) {
459			$sqlLogger = $this->getOption('sql_logger');
460
461			if ($sqlLogger instanceof SQLLogger) {
462			$this->SQLLogger = $sqlLogger;
463			}
464			}
465
466			return $this->SQLLogger;
467			}
468
469			/**
470			* Retrieve custom DQL string functions.
471			*
472			* @return array
473			*/
474			protected function getCustomStringFunctions()
475			{
476			$functions = (array) $this->getOption('custom_string_functions');
477
478			return array_filter(
479			$functions,
480			function ($name) {
481			return is_string($name);
482			},
483			ARRAY_FILTER_USE_KEY
484			);
485			}
486
487			/**
488			* Retrieve custom DQL numeric functions.
489			*
490			* @return array
491			*/
492			protected function getCustomNumericFunctions()
493			{
494			$functions = (array) $this->getOption('custom_numeric_functions');
495
496			return array_filter(
497			$functions,
498			function ($name) {
499			return is_string($name);
500			},
501			ARRAY_FILTER_USE_KEY
502			);
503			}
504
505			/**
506			* Retrieve custom DQL date time functions.
507			*
508			* @return array
509			*/
510			protected function getCustomDateTimeFunctions()
511			{
512			$functions = (array) $this->getOption('custom_datetime_functions');
513
514			return array_filter(
515			$functions,
516			function ($name) {
517			return is_string($name);
518			},
519			ARRAY_FILTER_USE_KEY
520			);
521			}
522
523			/**
524			* Retrieve custom DBAL types.
525			*
526			* @return array
527			*/
528			protected function getCustomTypes()
529			{
530			$types = (array) $this->getOption('custom_types');
531
532			return array_filter(
533			$types,
534			function ($name) {
535			return is_string($name);
536			},
537			ARRAY_FILTER_USE_KEY
538			);
539			}
540
541			/**
542			* Retrieve custom DBAL mapping types.
543			*
544			* @return array
545			*/
546			protected function getCustomMappingTypes()
547			{
548			$mappingTypes = (array) $this->getOption('custom_mapping_types');
549
550			return array_filter(
551			$mappingTypes,
552			function ($name) {
553			return is_string($name);
554			},
555			ARRAY_FILTER_USE_KEY
556			);
557			}
558
559			/**
560			* Get custom registered filters.
561			*
562			* @return array
563			*/
564			protected function getCustomFilters()
565			{
566			$filters = (array) $this->getOption('custom_filters');
567
568			return array_filter(
569			$filters,
570			function ($name) {
571			return is_string($name);
572			},
573			ARRAY_FILTER_USE_KEY
574			);
575			}
576
577			/**
578			* {@inheritdoc}
579			*
580			* @throws \Doctrine\DBAL\DBALException
581			* @throws \Doctrine\ORM\ORMException
582			* @throws \InvalidArgumentException
583			* @throws \RuntimeException
584			* @throws \Symfony\Component\Console\Exception\InvalidArgumentException
585			* @throws \Symfony\Component\Console\Exception\LogicException
586			* @throws \UnexpectedValueException
587			*
588			* @return Command[]
589			*/
590			public function getConsoleCommands()
591			{
592			$commands = [
593			// DBAL
594			new \Doctrine\DBAL\Tools\Console\Command\RunSqlCommand(),
595			new \Doctrine\DBAL\Tools\Console\Command\ImportCommand(),
596
597			// ORM
598			new \Doctrine\ORM\Tools\Console\Command\ClearCache\MetadataCommand(),
599			new \Doctrine\ORM\Tools\Console\Command\ClearCache\ResultCommand(),
600			new \Doctrine\ORM\Tools\Console\Command\ClearCache\QueryCommand(),
601			new \Doctrine\ORM\Tools\Console\Command\SchemaTool\CreateCommand(),
602			new \Doctrine\ORM\Tools\Console\Command\SchemaTool\UpdateCommand(),
603			new \Doctrine\ORM\Tools\Console\Command\SchemaTool\DropCommand(),
604			new \Doctrine\ORM\Tools\Console\Command\EnsureProductionSettingsCommand(),
605			new \Doctrine\ORM\Tools\Console\Command\ConvertDoctrine1SchemaCommand(),
606			new \Doctrine\ORM\Tools\Console\Command\GenerateRepositoriesCommand(),
607			new \Doctrine\ORM\Tools\Console\Command\GenerateEntitiesCommand(),
608			new \Doctrine\ORM\Tools\Console\Command\GenerateProxiesCommand(),
609			new \Doctrine\ORM\Tools\Console\Command\ConvertMappingCommand(),
610			new \Doctrine\ORM\Tools\Console\Command\RunDqlCommand(),
611			new \Doctrine\ORM\Tools\Console\Command\ValidateSchemaCommand(),
612			new \Doctrine\ORM\Tools\Console\Command\InfoCommand(),
613			];
614
615			if (Version::compare('2.5') <= 0) {
616			$commands[] = new \Doctrine\ORM\Tools\Console\Command\MappingDescribeCommand();
617			}
618
619			$helperSet = $this->getConsoleHelperSet();
620			$commandPrefix = (string) $this->getName();
621
622			$commands = array_map(
623			function (Command $command) use ($helperSet, $commandPrefix) {
624			if ($commandPrefix !== '') {
625			$commandNames = array_map(
626			function ($commandName) use ($commandPrefix) {
627			return preg_replace('/^(dbal\|orm):/', '$1:' . $commandPrefix . ':', $commandName);
628			},
629			array_merge([$command->getName()], $command->getAliases())
630			);
631
632			$command->setName(array_shift($commandNames));
633			$command->setAliases($commandNames);
634			}
635
636			$command->setHelperSet($helperSet);
637
638			return $command;
639			},
640			$commands
641			);
642
643			return $commands;
644			}
645
646			/**
647			* Get console helper set.
648			*
649			* @return \Symfony\Component\Console\Helper\HelperSet
650			*/
651			protected function getConsoleHelperSet()
652			{
653			/* @var EntityManager $entityManager */
654			$entityManager = $this->getManager();
655
656			return new HelperSet([
657			'db' => new ConnectionHelper($entityManager->getConnection()),
658			'em' => new EntityManagerHelper($entityManager),
659			]);
660			}
661			}
662

juliangut / doctrine-manager-builder

Push — master ( 7f63d4...d30d0e )

RelationalBuilder::getCacheDriver() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like