Persisters::createHydrator() - Code Metrics - Inspection of "Schema Management" - as3io/As3ModlrBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#26)

by Joshua

created 2016-09-27 17:28 UTC

Persisters::createHydrator() A

↳ Parent: Persisters

Complexity

Conditions	1
Paths	1

Size

Total Lines	8
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	8
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	5
nc	1
nop	0

<?php

namespace As3\Bundle\ModlrBundle\DependencyInjection\ServiceLoader;

use As3\Bundle\ModlrBundle\DependencyInjection\Utility;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Definition;
use Symfony\Component\DependencyInjection\Reference;

/**
 * Loads persister services.
 *
 * @author  Jacob Bare <[email protected]>
 */
class Persisters implements ServiceLoaderInterface
{
    /**
     * {@inheritdoc}
     */
    public function load(array $config, ContainerBuilder $container)
    {
        $managerDef = $container->getDefinition(Utility::getAliasedName('storage_manager'));

        foreach ($config['persisters'] as $name => $persisterConfig) {
            $persisterName = Utility::getAliasedName(sprintf('persister.%s', $name));
            if (isset($persisterConfig['service'])) {
                // Custom persister.
                $container->setAlias($persisterName, Utility::cleanServiceName($persisterConfig['service']));
            } else {
                // Built-in persister.
                switch ($persisterConfig['type']) {
                    case 'mongodb':
                        $definition = $this->createMongoDbPersister($persisterName, $persisterConfig, $container);
                        break;
                    default:
                        throw new \RuntimeException(sprintf('The persister type "%s" is currently not supported.', $persisterConfig['type']));
                }
                $container->setDefinition($persisterName, $definition);
            }
            $managerDef->addMethodCall('addPersister', [new Reference($persisterName)]);
        }
        return $this;
    }

    /**
     * Creates the connection service definition.
     *
     * @param   array   $persisterConfig
     * @param   string  $configName         The name of the connection configuration service
     * @return  Definition
     */
    private function createConnection(array $persisterConfig, $configName)
    {
        $options = isset($persisterConfig['parameters']['options']) && is_array($persisterConfig['parameters']['options']) ? $persisterConfig['parameters']['options'] : [];
        $definition = new Definition(
            'Doctrine\MongoDB\Connection',
            [$persisterConfig['parameters']['host'], $options, new Reference($configName)]
        );
        $definition->setPublic(false);
        return $definition;
    }

    /**
     *
     * Creates the connection configuration service definition.
     *
     * @param   string              $persisterName
     * @param   array               $persisterConfig
     * @param   ContainerBuilder    $container
     * @return  Definition
     */
    private function createConfiguration($persisterName, array $persisterConfig, ContainerBuilder $container)
    {
        $configDef = new Definition('Doctrine\MongoDB\Configuration');
        $configDef->setPublic(false);

        if (isset($persisterConfig['parameters']['profiling']) && true == $persisterConfig['parameters']['profiling']) {
            $dataCollectorId = sprintf('%s.data_collector', $persisterName);
            $collectorDef = $this->createDataCollector();
            $container->setDefinition($dataCollectorId, $collectorDef);
            $configDef->addMethodCall('setLoggerCallable', [[new Reference($dataCollectorId), 'logQuery']]);
        } else {
            $loggerName = sprintf('%s.logger', $persisterName);
            $loggerDef = new Definition(
                Utility::getLibraryClass('Persister\MongoDb\Logger'),
                [new Reference('logger')]
            );
            $loggerDef->addTag('monolog.logger', ['channel' => 'as3_modlr']);
            $loggerDef->setPublic(false);
            $container->setDefinition($loggerName, $loggerDef);
            $configDef->addMethodCall('setLoggerCallable', [[new Reference($loggerName), 'logQuery']]);
        }
        return $configDef;
    }
    /**
     * Creates the persistence data collector service definition.
     *
     * @return  Definition
     */
    private function createDataCollector()
    {
        $definition = new Definition(
            Utility::getBundleClass('DataCollector\MongoDb\PrettyDataCollector')
        );
        $definition->addTag('data_collector', ['id' => 'as3persistermongodb', 'template' => 'As3ModlrBundle:Collector:mongodb']);
        $definition->setPublic(false);
        return $definition;
    }

    /**
     * Creates the persistence formatter service definition.
     *
     * @return  Definition
     */
    private function createFormatter()
    {
        $definition = new Definition(
            Utility::getLibraryClass('Persister\MongoDb\Formatter')
        );
        $definition->setPublic(false);
        return $definition;
    }

    /**
     * Creates the persistence hydrator service definition.
     *
     * @return  Definition
     */
    private function createHydrator()
    {
        $definition = new Definition(
            Utility::getLibraryClass('Persister\MongoDb\Hydrator')
        );
        $definition->setPublic(false);
        return $definition;
    }

    /**
     * Creates the MongoDB persister service definition.
     * Will also load support services.
     *
     * @param   string              $persisterName
     * @param   array               $persisterConfig
     * @param   ContainerBuilder    $container
     * @return  Definition
     */
    private function createMongoDbPersister($persisterName, array $persisterConfig, ContainerBuilder $container)
    {
        // Storage metadata
        $smfName = sprintf('%s.metadata', $persisterName);
        $definition = $this->createSmf();
        $container->setDefinition($smfName, $definition);

        // Configuration
        $configName = sprintf('%s.configuration', $persisterName);
        $definition = $this->createConfiguration($persisterName, $persisterConfig, $container);
        $container->setDefinition($configName, $definition);

        // Connection
        $conName = sprintf('%s.connection', $persisterName);
        $definition = $this->createConnection($persisterConfig, $configName);
        $container->setDefinition($conName, $definition);

        // Formatter
        $formatterName = sprintf('%s.formatter', $persisterName);
        $definition = $this->createFormatter();
        $container->setDefinition($formatterName, $definition);

        // Query
        $queryName = sprintf('%s.query', $persisterName);
        $definition = $this->createQuery($conName, $formatterName);
        $container->setDefinition($queryName, $definition);

        // Hydrator
        $hydratorName = sprintf('%s.hydrator', $persisterName);
        $definition = $this->createHydrator();
        $container->setDefinition($hydratorName, $definition);

        // Schema Manager
        $schemaManagerName = sprintf('%s.schema_manager', $persisterName);
        $definition = $this->createSchemaManager();
        $container->setDefinition($schemaManagerName, $definition);

        // Persister
        return new Definition(
            Utility::getLibraryClass('Persister\MongoDb\Persister'),
            [new Reference($queryName), new Reference($smfName), new Reference($hydratorName), new Reference($schemaManagerName)]
        );
    }

    /**
     * Creates the persistence schema manager service definition.
     *
     * @return  Definition
     */
    private function createSchemaManager()
    {
        $definition = new Definition(
            Utility::getLibraryClass('Persister\MongoDb\SchemaManager')
        );
        $definition->setPublic(false);
        return $definition;
    }

    /**
     * Creates the storage metadata factory service definition.
     *
     * @return  Definition
     */
    private function createSmf()
    {
        $definition = new Definition(
            Utility::getLibraryClass('Persister\MongoDb\StorageMetadataFactory'),
            [new Reference(Utility::getAliasedName('util.entity'))]
        );
        $definition->setPublic(false);
        return $definition;
    }

    private function createQuery($conName, $formatterName)
    {
        $definition = new Definition(
            Utility::getLibraryClass('Persister\MongoDb\Query'),
            [new Reference($conName), new Reference($formatterName)]
        );
        return $definition;
    }
}


1		<?php
2
3		namespace As3\Bundle\ModlrBundle\DependencyInjection\ServiceLoader;
4
5		use As3\Bundle\ModlrBundle\DependencyInjection\Utility;
6		use Symfony\Component\DependencyInjection\ContainerBuilder;
7		use Symfony\Component\DependencyInjection\Definition;
8		use Symfony\Component\DependencyInjection\Reference;
9
10		/**
11		* Loads persister services.
12		*
13		* @author Jacob Bare <[email protected]>
14		*/
15		class Persisters implements ServiceLoaderInterface
16		{
17		/**
18		* {@inheritdoc}
19		*/
20	View Code Duplication	public function load(array $config, ContainerBuilder $container)
21		{
22		$managerDef = $container->getDefinition(Utility::getAliasedName('storage_manager'));
23
24		foreach ($config['persisters'] as $name => $persisterConfig) {
25		$persisterName = Utility::getAliasedName(sprintf('persister.%s', $name));
26		if (isset($persisterConfig['service'])) {
27		// Custom persister.
28		$container->setAlias($persisterName, Utility::cleanServiceName($persisterConfig['service']));
29		} else {
30		// Built-in persister.
31		switch ($persisterConfig['type']) {
32		case 'mongodb':
33		$definition = $this->createMongoDbPersister($persisterName, $persisterConfig, $container);
34		break;
35		default:
36		throw new \RuntimeException(sprintf('The persister type "%s" is currently not supported.', $persisterConfig['type']));
37		}
38		$container->setDefinition($persisterName, $definition);
39		}
40		$managerDef->addMethodCall('addPersister', [new Reference($persisterName)]);
41		}
42		return $this;
43		}
44
45		/**
46		* Creates the connection service definition.
47		*
48		* @param array $persisterConfig
49		* @param string $configName The name of the connection configuration service
50		* @return Definition
51		*/
52		private function createConnection(array $persisterConfig, $configName)
53		{
54		$options = isset($persisterConfig['parameters']['options']) && is_array($persisterConfig['parameters']['options']) ? $persisterConfig['parameters']['options'] : [];
55		$definition = new Definition(
56		'Doctrine\MongoDB\Connection',
57		[$persisterConfig['parameters']['host'], $options, new Reference($configName)]
58		);
59		$definition->setPublic(false);
60		return $definition;
61		}
62
63		/**
64		*
65		* Creates the connection configuration service definition.
66		*
67		* @param string $persisterName
68		* @param array $persisterConfig
69		* @param ContainerBuilder $container
70		* @return Definition
71		*/
72		private function createConfiguration($persisterName, array $persisterConfig, ContainerBuilder $container)
73		{
74		$configDef = new Definition('Doctrine\MongoDB\Configuration');
75		$configDef->setPublic(false);
76
77		if (isset($persisterConfig['parameters']['profiling']) && true == $persisterConfig['parameters']['profiling']) {
78		$dataCollectorId = sprintf('%s.data_collector', $persisterName);
79		$collectorDef = $this->createDataCollector();
80		$container->setDefinition($dataCollectorId, $collectorDef);
81		$configDef->addMethodCall('setLoggerCallable', [[new Reference($dataCollectorId), 'logQuery']]);
82		} else {
83		$loggerName = sprintf('%s.logger', $persisterName);
84		$loggerDef = new Definition(
85		Utility::getLibraryClass('Persister\MongoDb\Logger'),
86		[new Reference('logger')]
87		);
88		$loggerDef->addTag('monolog.logger', ['channel' => 'as3_modlr']);
89		$loggerDef->setPublic(false);
90		$container->setDefinition($loggerName, $loggerDef);
91		$configDef->addMethodCall('setLoggerCallable', [[new Reference($loggerName), 'logQuery']]);
92		}
93		return $configDef;
94		}
95		/**
96		* Creates the persistence data collector service definition.
97		*
98		* @return Definition
99		*/
100		private function createDataCollector()
101		{
102		$definition = new Definition(
103		Utility::getBundleClass('DataCollector\MongoDb\PrettyDataCollector')
104		);
105		$definition->addTag('data_collector', ['id' => 'as3persistermongodb', 'template' => 'As3ModlrBundle:Collector:mongodb']);
106		$definition->setPublic(false);
107		return $definition;
108		}
109
110		/**
111		* Creates the persistence formatter service definition.
112		*
113		* @return Definition
114		*/
115		private function createFormatter()
116		{
117		$definition = new Definition(
118		Utility::getLibraryClass('Persister\MongoDb\Formatter')
119		);
120		$definition->setPublic(false);
121		return $definition;
122		}
123
124		/**
125		* Creates the persistence hydrator service definition.
126		*
127		* @return Definition
128		*/
129		private function createHydrator()
130		{
131		$definition = new Definition(
132		Utility::getLibraryClass('Persister\MongoDb\Hydrator')
133		);
134		$definition->setPublic(false);
135		return $definition;
136		}
137
138		/**
139		* Creates the MongoDB persister service definition.
140		* Will also load support services.
141		*
142		* @param string $persisterName
143		* @param array $persisterConfig
144		* @param ContainerBuilder $container
145		* @return Definition
146		*/
147		private function createMongoDbPersister($persisterName, array $persisterConfig, ContainerBuilder $container)
148		{
149		// Storage metadata
150		$smfName = sprintf('%s.metadata', $persisterName);
151		$definition = $this->createSmf();
152		$container->setDefinition($smfName, $definition);
153
154		// Configuration
155		$configName = sprintf('%s.configuration', $persisterName);
156		$definition = $this->createConfiguration($persisterName, $persisterConfig, $container);
157		$container->setDefinition($configName, $definition);
158
159		// Connection
160		$conName = sprintf('%s.connection', $persisterName);
161		$definition = $this->createConnection($persisterConfig, $configName);
162		$container->setDefinition($conName, $definition);
163
164		// Formatter
165		$formatterName = sprintf('%s.formatter', $persisterName);
166		$definition = $this->createFormatter();
167		$container->setDefinition($formatterName, $definition);
168
169		// Query
170		$queryName = sprintf('%s.query', $persisterName);
171		$definition = $this->createQuery($conName, $formatterName);
172		$container->setDefinition($queryName, $definition);
173
174		// Hydrator
175		$hydratorName = sprintf('%s.hydrator', $persisterName);
176		$definition = $this->createHydrator();
177		$container->setDefinition($hydratorName, $definition);
178
179		// Schema Manager
180		$schemaManagerName = sprintf('%s.schema_manager', $persisterName);
181		$definition = $this->createSchemaManager();
182		$container->setDefinition($schemaManagerName, $definition);
183
184		// Persister
185		return new Definition(
186		Utility::getLibraryClass('Persister\MongoDb\Persister'),
187		[new Reference($queryName), new Reference($smfName), new Reference($hydratorName), new Reference($schemaManagerName)]
188		);
189		}
190
191		/**
192		* Creates the persistence schema manager service definition.
193		*
194		* @return Definition
195		*/
196		private function createSchemaManager()
197		{
198		$definition = new Definition(
199		Utility::getLibraryClass('Persister\MongoDb\SchemaManager')
200		);
201		$definition->setPublic(false);
202		return $definition;
203		}
204
205		/**
206		* Creates the storage metadata factory service definition.
207		*
208		* @return Definition
209		*/
210	View Code Duplication	private function createSmf()
211		{
212		$definition = new Definition(
213		Utility::getLibraryClass('Persister\MongoDb\StorageMetadataFactory'),
214		[new Reference(Utility::getAliasedName('util.entity'))]
215		);
216		$definition->setPublic(false);
217		return $definition;
218		}
219
220		private function createQuery($conName, $formatterName)
221		{
222		$definition = new Definition(
223		Utility::getLibraryClass('Persister\MongoDb\Query'),
224		[new Reference($conName), new Reference($formatterName)]
225		);
226		return $definition;
227		}
228		}
229

as3io / As3ModlrBundle

Pull Request — master (#26)

Persisters::createHydrator() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like