Persisters::createHydrator() - Code Metrics - Inspection of "Merge pull request #22 from zarathustra323/paginat..." - as3io/As3ModlrBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 3c3ca2...64cc96 )

by Jacob

created 2016-04-26 19:48 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	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	8
rs	9.4285
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.
     *
     * @return  Definition
     */
    private function createConfiguration($persisterName, $container)
    {
        $loggerName = sprintf('%s.logger', $persisterName);
        $definition = new Definition(
            Utility::getLibraryClass('Persister\MongoDb\Logger'),
            [new Reference('logger')]
        );
        $definition->addTag('monolog.logger', ['channel' => 'as3_modlr']);
        $definition->setPublic(false);
        $container->setDefinition($loggerName, $definition);

        $definition = new Definition('Doctrine\MongoDB\Configuration');
        $definition->addMethodCall('setLoggerCallable', [[new Reference($loggerName), 'logQuery']]);
        $definition->addTag('monolog.logger', ['channel' => 'as3_modlr']);
        $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, $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);

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

    /**
     * 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		* Creates the connection configuration service definition.
65		*
66		* @return Definition
67		*/
68		private function createConfiguration($persisterName, $container)
69		{
70		$loggerName = sprintf('%s.logger', $persisterName);
71		$definition = new Definition(
72		Utility::getLibraryClass('Persister\MongoDb\Logger'),
73		[new Reference('logger')]
74		);
75		$definition->addTag('monolog.logger', ['channel' => 'as3_modlr']);
76		$definition->setPublic(false);
77		$container->setDefinition($loggerName, $definition);
78
79		$definition = new Definition('Doctrine\MongoDB\Configuration');
80		$definition->addMethodCall('setLoggerCallable', [[new Reference($loggerName), 'logQuery']]);
81		$definition->addTag('monolog.logger', ['channel' => 'as3_modlr']);
82		$definition->setPublic(false);
83		return $definition;
84		}
85
86		/**
87		* Creates the persistence formatter service definition.
88		*
89		* @return Definition
90		*/
91		private function createFormatter()
92		{
93		$definition = new Definition(
94		Utility::getLibraryClass('Persister\MongoDb\Formatter')
95		);
96		$definition->setPublic(false);
97		return $definition;
98		}
99
100		/**
101		* Creates the persistence hydrator service definition.
102		*
103		* @return Definition
104		*/
105		private function createHydrator()
106		{
107		$definition = new Definition(
108		Utility::getLibraryClass('Persister\MongoDb\Hydrator')
109		);
110		$definition->setPublic(false);
111		return $definition;
112		}
113
114		/**
115		* Creates the MongoDB persister service definition.
116		* Will also load support services.
117		*
118		* @param string $persisterName
119		* @param array $persisterConfig
120		* @param ContainerBuilder $container
121		* @return Definition
122		*/
123		private function createMongoDbPersister($persisterName, array $persisterConfig, ContainerBuilder $container)
124		{
125		// Storage metadata
126		$smfName = sprintf('%s.metadata', $persisterName);
127		$definition = $this->createSmf();
128		$container->setDefinition($smfName, $definition);
129
130		// Configuration
131		$configName = sprintf('%s.configuration', $persisterName);
132		$definition = $this->createConfiguration($persisterName, $container);
133		$container->setDefinition($configName, $definition);
134
135		// Connection
136		$conName = sprintf('%s.connection', $persisterName);
137		$definition = $this->createConnection($persisterConfig, $configName);
138		$container->setDefinition($conName, $definition);
139
140		// Formatter
141		$formatterName = sprintf('%s.formatter', $persisterName);
142		$definition = $this->createFormatter();
143		$container->setDefinition($formatterName, $definition);
144
145		// Query
146		$queryName = sprintf('%s.query', $persisterName);
147		$definition = $this->createQuery($conName, $formatterName);
148		$container->setDefinition($queryName, $definition);
149
150		// Hydrator
151		$hydratorName = sprintf('%s.hydrator', $persisterName);
152		$definition = $this->createHydrator();
153		$container->setDefinition($hydratorName, $definition);
154
155		// Persister
156		return new Definition(
157		Utility::getLibraryClass('Persister\MongoDb\Persister'),
158		[new Reference($queryName), new Reference($smfName), new Reference($hydratorName)]
159		);
160		}
161
162		/**
163		* Creates the storage metadata factory service definition.
164		*
165		* @return Definition
166		*/
167	View Code Duplication	private function createSmf()
168		{
169		$definition = new Definition(
170		Utility::getLibraryClass('Persister\MongoDb\StorageMetadataFactory'),
171		[new Reference(Utility::getAliasedName('util.entity'))]
172		);
173		$definition->setPublic(false);
174		return $definition;
175		}
176
177		private function createQuery($conName, $formatterName)
178		{
179		$definition = new Definition(
180		Utility::getLibraryClass('Persister\MongoDb\Query'),
181		[new Reference($conName), new Reference($formatterName)]
182		);
183		return $definition;
184		}
185		}
186

as3io / As3ModlrBundle

Push — master ( 3c3ca2...64cc96 )

Persisters::createHydrator() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like