ManagerBuilder::getCLIApplication() - Code Metrics - Inspection of "control global annotation loader" - juliangut/slim-doctrine - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( d64f64...b5200d )

by Julián

created 2016-09-27 21:54 UTC

ManagerBuilder::getCLIApplication() A

↳ Parent: ManagerBuilder

Complexity

Conditions	3
Paths	3

Size

Total Lines	17
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	17
rs	9.4285
c	0
b	0
f	0
cc	3
eloc	9
nc	3
nop	0

<?php
/**
 * Slim3 Doctrine integration (https://github.com/juliangut/slim-doctrine)
 *
 * @link https://github.com/juliangut/slim-doctrine for the canonical source repository
 *
 * @license https://raw.githubusercontent.com/juliangut/slim-doctrine/master/LICENSE
 */

namespace Jgut\Slim\Doctrine;

use Doctrine\Common\Annotations\AnnotationRegistry;
use Jgut\Doctrine\ManagerBuilder\AbstractBuilderCollection;
use Jgut\Doctrine\ManagerBuilder\CouchDBBuilder;
use Jgut\Doctrine\ManagerBuilder\ManagerBuilder as Builder;
use Jgut\Doctrine\ManagerBuilder\MongoDBBuilder;
use Jgut\Doctrine\ManagerBuilder\RelationalBuilder;
use Symfony\Component\Console\Application;

/**
 * Slim-Doctrine managers integration.
 */
class ManagerBuilder extends AbstractBuilderCollection
{
    const METADATA_MAPPING_ANNOTATION = Builder::METADATA_MAPPING_ANNOTATION;
    const METADATA_MAPPING_XML = Builder::METADATA_MAPPING_XML;
    const METADATA_MAPPING_YAML = Builder::METADATA_MAPPING_YAML;
    const METADATA_MAPPING_PHP = Builder::METADATA_MAPPING_PHP;

    /**
     * Global annotation loader control.
     *
     * @var bool
     */
    protected $globalLoaderRegister = true;

    /**
     * Load Doctrine managers from settings array.
     *
     * @param array $settings
     *
     * @throws \RuntimeException
     *
     * @return $this
     */
    public function loadSettings(array $settings)
    {
        if (array_key_exists('entity_manager', $settings)) {
            $this->registerEntityManagers((array) $settings['entity_manager']);
        }

        if (array_key_exists('mongodb_document_manager', $settings)) {
            $this->registerMongoDBDocumentManagers((array) $settings['mongodb_document_manager']);
        }

        if (array_key_exists('couchdb_document_manager', $settings)) {
            $this->registerCouchDBDocumentManagers((array) $settings['couchdb_document_manager']);
        }

        return $this;
    }

    /**
     * Register ORM entity managers.
     *
     * @param array $settings
     *
     * @throws \RuntimeException
     */
    protected function registerEntityManagers(array $settings)
    {
        if (array_key_exists('connection', $settings)) {
            $settings = [$settings];
        }

        foreach ($settings as $name => $config) {
            if (!is_string($name)) {
                $name = 'entityManager';
            }

            $this->addBuilder(new RelationalBuilder($config, $name));
        }
    }

    /**
     * Register MongoDB ODM document managers.
     *
     * @param array $settings
     *
     * @throws \RuntimeException
     */
    protected function registerMongoDBDocumentManagers(array $settings)
    {
        if (array_key_exists('connection', $settings)) {
            $settings = [$settings];
        }

        foreach ($settings as $name => $config) {
            if (!is_string($name)) {
                $name = 'mongoDocumentManager';
            }

            $this->addBuilder(new MongoDBBuilder($config, $name));
        }
    }

    /**
     * Register CouchDB ODM document managers.
     *
     * @param array $settings
     *
     * @throws \RuntimeException
     */
    protected function registerCouchDBDocumentManagers(array $settings)
    {
        if (array_key_exists('connection', $settings)) {
            $settings = [$settings];
        }

        foreach ($settings as $name => $config) {
            if (!is_string($name)) {
                $name = 'couchDocumentManager';
            }

            $this->addBuilder(new CouchDBBuilder($config, $name));
        }
    }

    /**
     * Get registered builder's managers.
     *
     * @return \Doctrine\Common\Persistence\ObjectManager[]
     */
    public function getManagers()
    {
        $managers = array_map(
            function (Builder $builder) {
                return $builder->getManager();
            },
            $this->builders
        );

        $this->registerGlobalAnnotationLoader();

        return $managers;
    }

    /**
     * Get registered builder's manager.
     *
     * @param string $name
     *
     * @throws \RuntimeException
     *
     * @return \Doctrine\Common\Persistence\ObjectManager
     */
    public function getManager($name)
    {
        $builder = $this->getBuilder($name);
        if (!$builder instanceof Builder) {
            throw new \RuntimeException(sprintf('"%s" is not a registered manager', $name));
        }

        $manager = $builder->getManager();

        $this->registerGlobalAnnotationLoader();

        return $manager;
    }

    /**
     * Get console application.
     *
     * @return Application
     */
    public function getCLIApplication()
    {
        $application = new Application('Doctrine Manager Builder Command Line Interface');
        $application->setCatchExceptions(true);

        foreach ($this->builders as $builder) {
            $helperSet = $builder->getConsoleHelperSet();

            foreach ($builder->getConsoleCommands() as $command) {
                $application->add($command)->setHelperSet($helperSet);
            }
        }

        $this->registerGlobalAnnotationLoader();

        return $application;
    }

    /**
     * Register global annotation loader.
     * class_exists function.
     */
    protected function registerGlobalAnnotationLoader()
    {
        if ($this->globalLoaderRegister) {
            AnnotationRegistry::registerLoader('class_exists');

            $this->globalLoaderRegister = false;
        }
    }
}


1			<?php
2			/**
3			* Slim3 Doctrine integration (https://github.com/juliangut/slim-doctrine)
4			*
5			* @link https://github.com/juliangut/slim-doctrine for the canonical source repository
6			*
7			* @license https://raw.githubusercontent.com/juliangut/slim-doctrine/master/LICENSE
8			*/
9
10			namespace Jgut\Slim\Doctrine;
11
12			use Doctrine\Common\Annotations\AnnotationRegistry;
13			use Jgut\Doctrine\ManagerBuilder\AbstractBuilderCollection;
14			use Jgut\Doctrine\ManagerBuilder\CouchDBBuilder;
15			use Jgut\Doctrine\ManagerBuilder\ManagerBuilder as Builder;
16			use Jgut\Doctrine\ManagerBuilder\MongoDBBuilder;
17			use Jgut\Doctrine\ManagerBuilder\RelationalBuilder;
18			use Symfony\Component\Console\Application;
19
20			/**
21			* Slim-Doctrine managers integration.
22			*/
23			class ManagerBuilder extends AbstractBuilderCollection
24			{
25			const METADATA_MAPPING_ANNOTATION = Builder::METADATA_MAPPING_ANNOTATION;
26			const METADATA_MAPPING_XML = Builder::METADATA_MAPPING_XML;
27			const METADATA_MAPPING_YAML = Builder::METADATA_MAPPING_YAML;
28			const METADATA_MAPPING_PHP = Builder::METADATA_MAPPING_PHP;
29
30			/**
31			* Global annotation loader control.
32			*
33			* @var bool
34			*/
35			protected $globalLoaderRegister = true;
36
37			/**
38			* Load Doctrine managers from settings array.
39			*
40			* @param array $settings
41			*
42			* @throws \RuntimeException
43			*
44			* @return $this
45			*/
46			public function loadSettings(array $settings)
47			{
48			if (array_key_exists('entity_manager', $settings)) {
49			$this->registerEntityManagers((array) $settings['entity_manager']);
50			}
51
52			if (array_key_exists('mongodb_document_manager', $settings)) {
53			$this->registerMongoDBDocumentManagers((array) $settings['mongodb_document_manager']);
54			}
55
56			if (array_key_exists('couchdb_document_manager', $settings)) {
57			$this->registerCouchDBDocumentManagers((array) $settings['couchdb_document_manager']);
58			}
59
60			return $this;
61			}
62
63			/**
64			* Register ORM entity managers.
65			*
66			* @param array $settings
67			*
68			* @throws \RuntimeException
69			*/
70			protected function registerEntityManagers(array $settings)
71			{
72			if (array_key_exists('connection', $settings)) {
73			$settings = [$settings];
74			}
75
76			foreach ($settings as $name => $config) {
77			if (!is_string($name)) {
78			$name = 'entityManager';
79			}
80
81			$this->addBuilder(new RelationalBuilder($config, $name));
82			}
83			}
84
85			/**
86			* Register MongoDB ODM document managers.
87			*
88			* @param array $settings
89			*
90			* @throws \RuntimeException
91			*/
92			protected function registerMongoDBDocumentManagers(array $settings)
93			{
94			if (array_key_exists('connection', $settings)) {
95			$settings = [$settings];
96			}
97
98			foreach ($settings as $name => $config) {
99			if (!is_string($name)) {
100			$name = 'mongoDocumentManager';
101			}
102
103			$this->addBuilder(new MongoDBBuilder($config, $name));
104			}
105			}
106
107			/**
108			* Register CouchDB ODM document managers.
109			*
110			* @param array $settings
111			*
112			* @throws \RuntimeException
113			*/
114			protected function registerCouchDBDocumentManagers(array $settings)
115			{
116			if (array_key_exists('connection', $settings)) {
117			$settings = [$settings];
118			}
119
120			foreach ($settings as $name => $config) {
121			if (!is_string($name)) {
122			$name = 'couchDocumentManager';
123			}
124
125			$this->addBuilder(new CouchDBBuilder($config, $name));
126			}
127			}
128
129			/**
130			* Get registered builder's managers.
131			*
132			* @return \Doctrine\Common\Persistence\ObjectManager[]
133			*/
134			public function getManagers()
135			{
136			$managers = array_map(
137			function (Builder $builder) {
138			return $builder->getManager();
139			},
140			$this->builders
141			);
142
143			$this->registerGlobalAnnotationLoader();
144
145			return $managers;
146			}
147
148			/**
149			* Get registered builder's manager.
150			*
151			* @param string $name
152			*
153			* @throws \RuntimeException
154			*
155			* @return \Doctrine\Common\Persistence\ObjectManager
156			*/
157			public function getManager($name)
158			{
159			$builder = $this->getBuilder($name);
160			if (!$builder instanceof Builder) {
161			throw new \RuntimeException(sprintf('"%s" is not a registered manager', $name));
162			}
163
164			$manager = $builder->getManager();
165
166			$this->registerGlobalAnnotationLoader();
167
168			return $manager;
169			}
170
171			/**
172			* Get console application.
173			*
174			* @return Application
175			*/
176			public function getCLIApplication()
177			{
178			$application = new Application('Doctrine Manager Builder Command Line Interface');
179			$application->setCatchExceptions(true);
180
181			foreach ($this->builders as $builder) {
182			$helperSet = $builder->getConsoleHelperSet();
183
184			foreach ($builder->getConsoleCommands() as $command) {
185			$application->add($command)->setHelperSet($helperSet);
186			}
187			}
188
189			$this->registerGlobalAnnotationLoader();
190
191			return $application;
192			}
193
194			/**
195			* Register global annotation loader.
196			* class_exists function.
197			*/
198			protected function registerGlobalAnnotationLoader()
199			{
200			if ($this->globalLoaderRegister) {
201			AnnotationRegistry::registerLoader('class_exists');
202
203			$this->globalLoaderRegister = false;
204			}
205			}
206			}
207

juliangut / slim-doctrine

Push — master ( d64f64...b5200d )

ManagerBuilder::getCLIApplication() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like