CouchDBBuilder::wipe() - Code Metrics - juliangut/doctrine-manager-builder - Measure and Improve Code Quality continuously with Scrutinizer

CouchDBBuilder::wipe() A
last analyzed 2018-10-30 14:44 UTC

↳ Parent: CouchDBBuilder

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	7
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?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\CouchDB\Tools\Console\Helper\CouchDBHelper;
use Doctrine\ODM\CouchDB\Configuration;
use Doctrine\ODM\CouchDB\DocumentRepository;
use Doctrine\ODM\CouchDB\Mapping\Driver\AnnotationDriver;
use Doctrine\ODM\CouchDB\Mapping\Driver\XmlDriver;
use Doctrine\ODM\CouchDB\Mapping\Driver\YamlDriver;
use Jgut\Doctrine\ManagerBuilder\CouchDB\DocumentManager;
use Jgut\Doctrine\ManagerBuilder\CouchDB\Repository\RepositoryFactory;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Helper\HelperSet;

/**
 * Doctrine CouchDB Document Manager builder.
 *
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class CouchDBBuilder extends AbstractManagerBuilder
{
    /**
     * {@inheritdoc}
     */
    protected function getDefaultOptions()
    {
        return [
            'connection' => [], // Array or \Doctrine\CouchDB\CouchDBClient
            'proxies_namespace' => 'DoctrineCouchDBODMProxy',
            'metadata_cache_namespace' => 'DoctrineCouchDBODMMetadataCache',
            'default_repository_class' => DocumentRepository::class,
        ];
    }

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

    /**
     * {@inheritdoc}
     *
     * @throws \InvalidArgumentException
     * @throws \RuntimeException
     * @throws \UnexpectedValueException
     *
     * @return DocumentManager
     */
    protected function buildManager()
    {
        $config = new Configuration;

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

        $documentManager = DocumentManager::create($this->getOption('connection'), $config, $this->getEventManager());

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

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

        return $documentManager;
    }

    /**
     * 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());

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

    /**
     * Set up manager specific configurations.
     *
     * @param Configuration $config
     */
    protected function setUpSpecificConfigurations(Configuration $config)
    {
        if ($this->getLuceneHandlerName() !== null) {
            $config->setLuceneHandlerName($this->getLuceneHandlerName());
        }
    }

    /**
     * {@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 Jgut\Doctrine\ManagerBuilder\CouchDB\RepositoryFactory.',
                get_class($repositoryFactory)
            ));
        }

        return $repositoryFactory;
    }

    /**
     * Get Lucene handler name.
     *
     * @return string|null
     */
    protected function getLuceneHandlerName()
    {
        return $this->hasOption('lucene_handler_name') ? (string) $this->getOption('lucene_handler_name') : null;
    }

    /**
     * {@inheritdoc}
     *
     * @throws \InvalidArgumentException
     * @throws \RuntimeException
     * @throws \Symfony\Component\Console\Exception\InvalidArgumentException
     * @throws \Symfony\Component\Console\Exception\LogicException
     * @throws \UnexpectedValueException
     *
     * @return Command[]
     */
    public function getConsoleCommands()
    {
        $commands = [
            // CouchDB
            new \Doctrine\CouchDB\Tools\Console\Command\ReplicationStartCommand,
            new \Doctrine\CouchDB\Tools\Console\Command\ReplicationCancelCommand,
            new \Doctrine\CouchDB\Tools\Console\Command\ViewCleanupCommand,
            new \Doctrine\CouchDB\Tools\Console\Command\CompactDatabaseCommand,
            new \Doctrine\CouchDB\Tools\Console\Command\CompactViewCommand,
            new \Doctrine\CouchDB\Tools\Console\Command\MigrationCommand,

            // ODM
            new \Doctrine\ODM\CouchDB\Tools\Console\Command\GenerateProxiesCommand,
            new \Doctrine\ODM\CouchDB\Tools\Console\Command\UpdateDesignDocCommand,
        ];

        $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) {
                            $key = preg_match('/^couchdb:odm:/', $commandName) ? 'couchdb_odm' : 'couchdb';

                            return preg_replace(
                                '/^couchdb:(odm:)?/',
                                $key . ':' . $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 DocumentManager $documentManager */
        $documentManager = $this->getManager();

        return new HelperSet([
            'dm' => new CouchDBHelper($documentManager->getCouchDBClient(), $documentManager),
        ]);
    }
}


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\CouchDB\Tools\Console\Helper\CouchDBHelper;
16			use Doctrine\ODM\CouchDB\Configuration;
17			use Doctrine\ODM\CouchDB\DocumentRepository;
18			use Doctrine\ODM\CouchDB\Mapping\Driver\AnnotationDriver;
19			use Doctrine\ODM\CouchDB\Mapping\Driver\XmlDriver;
20			use Doctrine\ODM\CouchDB\Mapping\Driver\YamlDriver;
21			use Jgut\Doctrine\ManagerBuilder\CouchDB\DocumentManager;
22			use Jgut\Doctrine\ManagerBuilder\CouchDB\Repository\RepositoryFactory;
23			use Symfony\Component\Console\Command\Command;
24			use Symfony\Component\Console\Helper\HelperSet;
25
26			/**
27			* Doctrine CouchDB Document Manager builder.
28			*
29			* @SuppressWarnings(PHPMD.CouplingBetweenObjects)
30			*/
31			class CouchDBBuilder extends AbstractManagerBuilder
32			{
33			/**
34			* {@inheritdoc}
35			*/
36			protected function getDefaultOptions()
37			{
38			return [
39			'connection' => [], // Array or \Doctrine\CouchDB\CouchDBClient
40			'proxies_namespace' => 'DoctrineCouchDBODMProxy',
41			'metadata_cache_namespace' => 'DoctrineCouchDBODMMetadataCache',
42			'default_repository_class' => DocumentRepository::class,
43			];
44			}
45
46			/**
47			* {@inheritdoc}
48			*/
49			protected function wipe()
50			{
51			$this->manager = null;
52			$this->mappingDriver = null;
53			$this->metadataCacheDriver = null;
54			$this->eventManager = null;
55			}
56
57			/**
58			* {@inheritdoc}
59			*
60			* @throws \InvalidArgumentException
61			* @throws \RuntimeException
62			* @throws \UnexpectedValueException
63			*
64			* @return DocumentManager
65			*/
66			protected function buildManager()
67			{
68			$config = new Configuration;
69
70			$this->setUpGeneralConfigurations($config);
71			$this->setUpSpecificConfigurations($config);
72
73			$documentManager = DocumentManager::create($this->getOption('connection'), $config, $this->getEventManager());
74
75			if ($this->getRepositoryFactory() !== null) {
76			$documentManager->setRepositoryFactory($this->getRepositoryFactory());
77			}
78
79			if ($this->getDefaultRepositoryClass() !== null) {
80			$documentManager->setDefaultRepositoryClassName($this->getDefaultRepositoryClass());
81			}
82
83			return $documentManager;
84			}
85
86			/**
87			* Set up general manager configurations.
88			*
89			* @param Configuration $config
90			*/
91			protected function setUpGeneralConfigurations(Configuration $config)
92			{
93			$this->setupAnnotationMetadata();
94			$config->setMetadataDriverImpl($this->getMetadataMappingDriver());
95
96			$config->setProxyDir($this->getProxiesPath());
97			$config->setProxyNamespace($this->getProxiesNamespace());
98			$config->setAutoGenerateProxyClasses($this->getProxiesAutoGeneration());
99
100			$config->setMetadataCacheImpl($this->getMetadataCacheDriver());
101			}
102
103			/**
104			* Set up manager specific configurations.
105			*
106			* @param Configuration $config
107			*/
108			protected function setUpSpecificConfigurations(Configuration $config)
109			{
110			if ($this->getLuceneHandlerName() !== null) {
111			$config->setLuceneHandlerName($this->getLuceneHandlerName());
112			}
113			}
114
115			/**
116			* {@inheritdoc}
117			*/
118			protected function getAnnotationMappingDriver(array $paths)
119			{
120			return new AnnotationDriver(new AnnotationReader, $paths);
121			}
122
123			/**
124			* {@inheritdoc}
125			*/
126			protected function getXmlMappingDriver(array $paths, $extension = null)
127			{
128			$extension = $extension ?: XmlDriver::DEFAULT_FILE_EXTENSION;
129
130			return new XmlDriver($paths, $extension);
131			}
132
133			/**
134			* {@inheritdoc}
135			*/
136			protected function getYamlMappingDriver(array $paths, $extension = null)
137			{
138			$extension = $extension ?: YamlDriver::DEFAULT_FILE_EXTENSION;
139
140			return new YamlDriver($paths, $extension);
141			}
142
143			/**
144			* {@inheritdoc}
145			*
146			* @throws \InvalidArgumentException
147			*
148			* @return RepositoryFactory\|null
149			*/
150			protected function getRepositoryFactory()
151			{
152			if (!array_key_exists('repository_factory', $this->options)) {
153			return;
154			}
155
156			$repositoryFactory = $this->options['repository_factory'];
157
158			if (!$repositoryFactory instanceof RepositoryFactory) {
159			throw new \InvalidArgumentException(sprintf(
160			'Invalid factory class "%s". It must be a Jgut\Doctrine\ManagerBuilder\CouchDB\RepositoryFactory.',
161			get_class($repositoryFactory)
162			));
163			}
164
165			return $repositoryFactory;
166			}
167
168			/**
169			* Get Lucene handler name.
170			*
171			* @return string\|null
172			*/
173			protected function getLuceneHandlerName()
174			{
175			return $this->hasOption('lucene_handler_name') ? (string) $this->getOption('lucene_handler_name') : null;
176			}
177
178			/**
179			* {@inheritdoc}
180			*
181			* @throws \InvalidArgumentException
182			* @throws \RuntimeException
183			* @throws \Symfony\Component\Console\Exception\InvalidArgumentException
184			* @throws \Symfony\Component\Console\Exception\LogicException
185			* @throws \UnexpectedValueException
186			*
187			* @return Command[]
188			*/
189			public function getConsoleCommands()
190			{
191			$commands = [
192			// CouchDB
193			new \Doctrine\CouchDB\Tools\Console\Command\ReplicationStartCommand,
194			new \Doctrine\CouchDB\Tools\Console\Command\ReplicationCancelCommand,
195			new \Doctrine\CouchDB\Tools\Console\Command\ViewCleanupCommand,
196			new \Doctrine\CouchDB\Tools\Console\Command\CompactDatabaseCommand,
197			new \Doctrine\CouchDB\Tools\Console\Command\CompactViewCommand,
198			new \Doctrine\CouchDB\Tools\Console\Command\MigrationCommand,
199
200			// ODM
201			new \Doctrine\ODM\CouchDB\Tools\Console\Command\GenerateProxiesCommand,
202			new \Doctrine\ODM\CouchDB\Tools\Console\Command\UpdateDesignDocCommand,
203			];
204
205			$helperSet = $this->getConsoleHelperSet();
206			$commandPrefix = (string) $this->getName();
207
208			$commands = array_map(
209			function (Command $command) use ($helperSet, $commandPrefix) {
210			if ($commandPrefix !== '') {
211			$commandNames = array_map(
212			function ($commandName) use ($commandPrefix) {
213			$key = preg_match('/^couchdb:odm:/', $commandName) ? 'couchdb_odm' : 'couchdb';
214
215			return preg_replace(
216			'/^couchdb:(odm:)?/',
217			$key . ':' . $commandPrefix . ':',
218			$commandName
219			);
220			},
221			array_merge([$command->getName()], $command->getAliases())
222			);
223
224			$command->setName(array_shift($commandNames));
225			$command->setAliases($commandNames);
226			}
227
228			$command->setHelperSet($helperSet);
229
230			return $command;
231			},
232			$commands
233			);
234
235			return $commands;
236			}
237
238			/**
239			* Get console helper set.
240			*
241			* @return \Symfony\Component\Console\Helper\HelperSet
242			*/
243			protected function getConsoleHelperSet()
244			{
245			/* @var DocumentManager $documentManager */
246			$documentManager = $this->getManager();
247
248			return new HelperSet([
249			'dm' => new CouchDBHelper($documentManager->getCouchDBClient(), $documentManager),
250			]);
251			}
252			}
253

juliangut / doctrine-manager-builder

CouchDBBuilder::wipe() A last analyzed 2018-10-30 14:44 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

CouchDBBuilder::wipe() A
last analyzed 2018-10-30 14:44 UTC