MathielenImportEngineExtension::generateObjectFactoryDef() - Code Metrics - Inspection of "no method-whitelisting for service provider" - mathielen/ImportEngineBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( ac3584...bafd7c )

by Markus

created 2015-12-09 10:22 UTC

generateObjectFactoryDef() A

↳ Parent: MathielenImportEngineExtension

Complexity

Conditions	3
Paths	3

Size

Total Lines	14
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	12

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
c	2
b	0
f	0
dl	0
loc	14
ccs	0
cts	8
cp	0
rs	9.4286
cc	3
eloc	8
nc	3
nop	1
crap	12

<?php
namespace Mathielen\ImportEngineBundle\DependencyInjection;

use Mathielen\ImportEngine\Exception\InvalidConfigurationException;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
use Symfony\Component\DependencyInjection\Extension\Extension;
use Symfony\Component\Config\FileLocator;
use Symfony\Component\DependencyInjection\Reference;
use Symfony\Component\DependencyInjection\Definition;
use Symfony\Component\ExpressionLanguage\Expression;

class MathielenImportEngineExtension extends Extension
{

    public function load(array $configs, ContainerBuilder $container)
    {
        $config = $this->processConfiguration(new Configuration(), $configs);

        if (!empty($config['importers'])) {
            $loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
            $loader->load('services.xml');

            $this->parseConfig($config, $container);
        }
    }

    private function parseConfig(array $config, ContainerBuilder $container)
    {
        $storageLocatorDef = $container->findDefinition('mathielen_importengine.import.storagelocator');
        foreach ($config['storageprovider'] as $name => $sourceConfig) {
            $this->addStorageProviderDef($storageLocatorDef, $sourceConfig, $name);
        }

        $importerRepositoryDef = $container->findDefinition('mathielen_importengine.importer.repository');
        foreach ($config['importers'] as $name => $importConfig) {
            $finderDef = null;
            if (isset($importConfig['preconditions'])) {
                $finderDef = $this->generateFinderDef($importConfig['preconditions']);
            }

            $objectFactoryDef = null;
            if (isset($importConfig['object_factory'])) {
                $objectFactoryDef = $this->generateObjectFactoryDef($importConfig['object_factory']);
            }

            $importerRepositoryDef->addMethodCall('register', array(
                $name,
                $this->generateImporterDef($importConfig, $objectFactoryDef),
                $finderDef
            ));
        }
    }

    private function generateObjectFactoryDef(array $config)
    {
        if (!class_exists($config['class'])) {
            throw new InvalidConfigurationException("Object-Factory target-class '".$config['class']."' does not exist.");
        }

        if ($config['type'] == 'jms_serializer') {
            return new Definition('Mathielen\DataImport\Writer\ObjectWriter\JmsSerializerObjectFactory', array(
                $config['class'],
                new Reference('jms_serializer')));
        }

        return new Definition('Mathielen\DataImport\Writer\ObjectWriter\DefaultObjectFactory', array($config['class']));
    }

    /**
     * @return \Symfony\Component\DependencyInjection\Definition
     */
    private function generateFinderDef(array $finderConfig)
    {
        $finderDef = new Definition('Mathielen\ImportEngine\Importer\ImporterPrecondition');

        if (isset($finderConfig['filename'])) {
            foreach ($finderConfig['filename'] as $conf) {
                $finderDef->addMethodCall('filename', array($conf));
            }
        }

        if (isset($finderConfig['format'])) {

            foreach ($finderConfig['format'] as $conf) {
                $finderDef->addMethodCall('format', array($conf));
            }
        }

        if (isset($finderConfig['fieldcount'])) {
            $finderDef->addMethodCall('fieldcount', array($finderConfig['fieldcount']));
        }

        if (isset($finderConfig['fields'])) {

            foreach ($finderConfig['fields'] as $conf) {
                $finderDef->addMethodCall('field', array($conf));
            }
        }

        if (isset($finderConfig['fieldset'])) {
            $finderDef->addMethodCall('fieldset', array($finderConfig['fieldset']));
        }

        return $finderDef;
    }

    /**
     * @return \Symfony\Component\DependencyInjection\Definition
     */
    private function generateImporterDef(array $importConfig, Definition $objectFactoryDef=null)
    {
        $importerDef = new Definition('Mathielen\ImportEngine\Importer\Importer', array(
            $this->getStorageDef($importConfig['target'], $objectFactoryDef)
        ));

        if (isset($importConfig['source'])) {
            $this->setSourceStorageDef($importConfig['source'], $importerDef);
        }

        //enable validation?
        if (isset($importConfig['validation']) && !empty($importConfig['validation'])) {
            $this->generateValidationDef($importConfig['validation'], $importerDef, $objectFactoryDef);
        }

        //add converters?
        if (isset($importConfig['mappings']) && !empty($importConfig['mappings'])) {
            $this->generateTransformerDef($importConfig['mappings'], $importerDef);
        }

        //add filters?
        if (isset($importConfig['filters']) && !empty($importConfig['filters'])) {
            $this->generateFiltersDef($importConfig['filters'], $importerDef);
        }

        //has static context?
        if (isset($importConfig['context'])) {
            $importerDef->addMethodCall('setContext', array(
                $importConfig['context']
            ));
        }

        return $importerDef;
    }

    private function generateFiltersDef(array $filtersOptions, Definition $importerDef)
    {
        $filtersDef = new Definition('Mathielen\ImportEngine\Filter\Filters');

        foreach ($filtersOptions as $filtersOption) {
            $filtersDef->addMethodCall('add', array(
                new Reference($filtersOption)
            ));
        }

        $importerDef->addMethodCall('filters', array(
            $filtersDef
        ));
    }

    private function generateTransformerDef(array $mappingOptions, Definition $importerDef)
    {
        $mappingsDef = new Definition('Mathielen\ImportEngine\Mapping\Mappings');

        //set converters
        foreach ($mappingOptions as $field=>$fieldMapping) {
            $converter = null;
            if (isset($fieldMapping['converter'])) {
                $converter = $fieldMapping['converter'];
            }

            if (isset($fieldMapping['to'])) {
                $mappingsDef->addMethodCall('add', array(
                    $field,
                    $fieldMapping['to'],
                    $converter
            ));
            } elseif ($converter) {
                $mappingsDef->addMethodCall('setConverter', array(
                    $converter,
                    $field
                ));
            }
        }

        $mappingFactoryDef = new Definition('Mathielen\ImportEngine\Mapping\DefaultMappingFactory', array(
            $mappingsDef
        ));
        $converterProviderDef = new Definition('Mathielen\ImportEngine\Mapping\Converter\Provider\ContainerAwareConverterProvider', array(
            new Reference('service_container')
        ));

        $transformerDef = new Definition('Mathielen\ImportEngine\Transformation\Transformation');
        $transformerDef->addMethodCall('setMappingFactory', array(
            $mappingFactoryDef
        ));
        $transformerDef->addMethodCall('setConverterProvider', array(
            $converterProviderDef
        ));

        $importerDef->addMethodCall('transformation', array(
            $transformerDef
        ));
    }

    private function generateValidatorDef(array $options)
    {
        //eventdispatcher aware source validatorfilter
        $validatorFilterDef = new Definition('Mathielen\DataImport\Filter\ValidatorFilter', array(
            new Reference('validator'),
            $options,
            new Reference('event_dispatcher')
        ));

        return $validatorFilterDef;
    }

    private function generateValidationDef(array $validationConfig, Definition $importerDef, Definition $objectFactoryDef=null)
    {
        $validationDef = new Definition('Mathielen\ImportEngine\Validation\ValidatorValidation', array(
            new Reference('validator')
        ));
        $importerDef->addMethodCall('validation', array(
            $validationDef
        ));

        $validatorFilterDef = $this->generateValidatorDef(
            isset($validationConfig['options'])?$validationConfig['options']:array()
        );

        if (isset($validationConfig['source'])) {
            $validationDef->addMethodCall('setSourceValidatorFilter', array(
                $validatorFilterDef
            ));

            foreach ($validationConfig['source']['constraints'] as $field=>$constraint) {
                $validationDef->addMethodCall('addSourceConstraint', array(
                    $field,
                    new Definition($constraint)
                ));
            }
        }

        //automatically apply class validation
        if (isset($validationConfig['target'])) {

            //using objects as result
            if ($objectFactoryDef) {

                //set eventdispatcher aware target CLASS-validatorfilter
                $validatorFilterDef = new Definition('Mathielen\DataImport\Filter\ClassValidatorFilter', array(
                    new Reference('validator'),
                    $objectFactoryDef,
                    new Reference('event_dispatcher')
                ));

            } else {
                foreach ($validationConfig['target']['constraints'] as $field=>$constraint) {
                    $validationDef->addMethodCall('addTargetConstraint', array(
                        $field,
                        new Definition($constraint)
                    ));
                }
            }

            $validationDef->addMethodCall('setTargetValidatorFilter', array(
                $validatorFilterDef
            ));
        }

        return $validationDef;
    }

    private function setSourceStorageDef(array $sourceConfig, Definition $importerDef)
    {
        $sDef = $this->getStorageDef($sourceConfig, $importerDef);
        $importerDef->addMethodCall('setSourceStorage', array(
            $sDef
        ));
    }

    private function addStorageProviderDef(Definition $storageLocatorDef, $config, $id = 'default')
    {
        $formatDiscoverLocalFileStorageFactoryDef = new Definition('Mathielen\ImportEngine\Storage\Factory\FormatDiscoverLocalFileStorageFactory', array(
            new Definition('Mathielen\ImportEngine\Storage\Format\Discovery\MimeTypeDiscoverStrategy', array(
                array(
                    'text/plain'=>new Definition('Mathielen\ImportEngine\Storage\Format\Factory\CsvAutoDelimiterFormatFactory'),
                    'text/csv'=>new Definition('Mathielen\ImportEngine\Storage\Format\Factory\CsvAutoDelimiterFormatFactory'),
                )
            )),
            new Reference('logger')
        ));

        switch ($config['type']) {
            case 'directory':
                $spFinderDef = new Definition('Symfony\Component\Finder\Finder');
                $spFinderDef->addMethodCall('in', array(
                    $config['uri']
                ));
                $spDef = new Definition('Mathielen\ImportEngine\Storage\Provider\FinderFileStorageProvider', array(
                    $spFinderDef,
                    $formatDiscoverLocalFileStorageFactoryDef
                ));
                break;
            case 'upload':
                $spDef = new Definition('Mathielen\ImportEngine\Storage\Provider\UploadFileStorageProvider', array(
                    $config['uri'],
                    $formatDiscoverLocalFileStorageFactoryDef
                ));
                break;
            case 'doctrine':
                $spDef = new Definition('Mathielen\ImportEngine\Storage\Provider\DoctrineQueryStorageProvider', array(
                    new Reference('doctrine.orm.entity_manager'),
                    $config['queries']
                ));
                break;
            case 'service':
                $spDef = new Definition('Mathielen\ImportEngine\Storage\Provider\ServiceStorageProvider', array(
                    new Reference('service_container'),
                    $config['services']
                ));
                break;
            case 'file':
                $spDef = new Definition('Mathielen\ImportEngine\Storage\Provider\FileStorageProvider', array(
                    $formatDiscoverLocalFileStorageFactoryDef
                ));
                break;
            default:
                throw new InvalidConfigurationException('Unknown type for storage provider: '.$config['type']);
        }

        $storageLocatorDef->addMethodCall('register', array(
            $id,
            $spDef
        ));
    }

    private function getStorageFileDefinitionFromUri($uri)
    {
        if (substr($uri, 0, 2) === '@=') {
            $uri = new Expression(substr($uri, 2));
        }

        return new Definition('SplFileInfo', array(
            $uri
        ));
    }

    /**
     * @return Definition
     */
    private function getStorageDef(array $config, Definition $objectFactoryDef=null)
    {
        switch ($config['type']) {
            case 'file':
                $fileDef = $this->getStorageFileDefinitionFromUri($config['uri']);

                $format = $config['format'];
                $storageDef = new Definition('Mathielen\ImportEngine\Storage\LocalFileStorage', array(
                    $fileDef,
                    new Definition('Mathielen\ImportEngine\Storage\Format\\'.ucfirst($format['type'])."Format", $format['arguments'])
                ));

                break;
            case 'doctrine':
                $storageDef = new Definition('Mathielen\ImportEngine\Storage\DoctrineStorage', array(
                    new Reference('doctrine.orm.entity_manager'),
                    $config['entity']
                ));

                break;
            case 'service':
                $storageDef = new Definition('Mathielen\ImportEngine\Storage\ServiceStorage', array(
                    array(new Reference($config['service']), $config['method']), //callable
                    array(),
                    $objectFactoryDef //from parameter array
                ));

                break;
            default:
                throw new InvalidConfigurationException('Unknown type for storage: '.$config['type']);
        }

        return $storageDef;
    }

    public function getAlias()
    {
        return 'mathielen_import_engine';
    }
}


1			<?php
2			namespace Mathielen\ImportEngineBundle\DependencyInjection;
3
4			use Mathielen\ImportEngine\Exception\InvalidConfigurationException;
5			use Symfony\Component\DependencyInjection\ContainerBuilder;
6			use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
7			use Symfony\Component\DependencyInjection\Extension\Extension;
8			use Symfony\Component\Config\FileLocator;
9			use Symfony\Component\DependencyInjection\Reference;
10			use Symfony\Component\DependencyInjection\Definition;
11			use Symfony\Component\ExpressionLanguage\Expression;
12
13			class MathielenImportEngineExtension extends Extension
14			{
15
16	11		public function load(array $configs, ContainerBuilder $container)
17			{
18	11		$config = $this->processConfiguration(new Configuration(), $configs);
19
20	6		if (!empty($config['importers'])) {
21	4		$loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
22	4		$loader->load('services.xml');
23
24	4		$this->parseConfig($config, $container);
25	4		}
26	6		}
27
28	4		private function parseConfig(array $config, ContainerBuilder $container)
29			{
30	4		$storageLocatorDef = $container->findDefinition('mathielen_importengine.import.storagelocator');
31	4		foreach ($config['storageprovider'] as $name => $sourceConfig) {
32			$this->addStorageProviderDef($storageLocatorDef, $sourceConfig, $name);
33	4		}
34
35	4		$importerRepositoryDef = $container->findDefinition('mathielen_importengine.importer.repository');
36	4		foreach ($config['importers'] as $name => $importConfig) {
37	4		$finderDef = null;
38	4		if (isset($importConfig['preconditions'])) {
39			$finderDef = $this->generateFinderDef($importConfig['preconditions']);
40			}
41
42	4		$objectFactoryDef = null;
43	4		if (isset($importConfig['object_factory'])) {
44			$objectFactoryDef = $this->generateObjectFactoryDef($importConfig['object_factory']);
45			}
46
47	4		$importerRepositoryDef->addMethodCall('register', array(
48	4		$name,
49	4		$this->generateImporterDef($importConfig, $objectFactoryDef),
50			$finderDef
51	4		));
52	4		}
53	4		}
54
55			private function generateObjectFactoryDef(array $config)
56			{
57			if (!class_exists($config['class'])) {
58			throw new InvalidConfigurationException("Object-Factory target-class '".$config['class']."' does not exist.");
59			}
60
61			if ($config['type'] == 'jms_serializer') {
62			return new Definition('Mathielen\DataImport\Writer\ObjectWriter\JmsSerializerObjectFactory', array(
63			$config['class'],
64			new Reference('jms_serializer')));
65			}
66
67			return new Definition('Mathielen\DataImport\Writer\ObjectWriter\DefaultObjectFactory', array($config['class']));
68			}
69
70			/**
71			* @return \Symfony\Component\DependencyInjection\Definition
72			*/
73	1		private function generateFinderDef(array $finderConfig)
74			{
75			$finderDef = new Definition('Mathielen\ImportEngine\Importer\ImporterPrecondition');
76
77			if (isset($finderConfig['filename'])) {
78			foreach ($finderConfig['filename'] as $conf) {
79			$finderDef->addMethodCall('filename', array($conf));
80			}
81			}
82
83		View Code Duplication	if (isset($finderConfig['format'])) {
			0 ignored issues – show Duplication introduced 2015-12-04 08:37 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
84			foreach ($finderConfig['format'] as $conf) {
85			$finderDef->addMethodCall('format', array($conf));
86			}
87			}
88
89			if (isset($finderConfig['fieldcount'])) {
90			$finderDef->addMethodCall('fieldcount', array($finderConfig['fieldcount']));
91			}
92
93		View Code Duplication	if (isset($finderConfig['fields'])) {
			0 ignored issues – show Duplication introduced 2015-12-04 08:37 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
94			foreach ($finderConfig['fields'] as $conf) {
95			$finderDef->addMethodCall('field', array($conf));
96			}
97			}
98
99			if (isset($finderConfig['fieldset'])) {
100			$finderDef->addMethodCall('fieldset', array($finderConfig['fieldset']));
101			}
102
103	1		return $finderDef;
104			}
105
106			/**
107			* @return \Symfony\Component\DependencyInjection\Definition
108			*/
109	4		private function generateImporterDef(array $importConfig, Definition $objectFactoryDef=null)
110			{
111	4		$importerDef = new Definition('Mathielen\ImportEngine\Importer\Importer', array(
112	4		$this->getStorageDef($importConfig['target'], $objectFactoryDef)
113	4		));
114
115	4		if (isset($importConfig['source'])) {
116			$this->setSourceStorageDef($importConfig['source'], $importerDef);
117			}
118
119			//enable validation?
120	4		if (isset($importConfig['validation']) && !empty($importConfig['validation'])) {
121	2		$this->generateValidationDef($importConfig['validation'], $importerDef, $objectFactoryDef);
122	2		}
123
124			//add converters?
125	4		if (isset($importConfig['mappings']) && !empty($importConfig['mappings'])) {
126			$this->generateTransformerDef($importConfig['mappings'], $importerDef);
127			}
128
129			//add filters?
130	4		if (isset($importConfig['filters']) && !empty($importConfig['filters'])) {
131			$this->generateFiltersDef($importConfig['filters'], $importerDef);
132			}
133
134			//has static context?
135	4		if (isset($importConfig['context'])) {
136	4		$importerDef->addMethodCall('setContext', array(
137	4		$importConfig['context']
138	4		));
139	4		}
140
141	4		return $importerDef;
142			}
143
144			private function generateFiltersDef(array $filtersOptions, Definition $importerDef)
145			{
146			$filtersDef = new Definition('Mathielen\ImportEngine\Filter\Filters');
147
148			foreach ($filtersOptions as $filtersOption) {
149			$filtersDef->addMethodCall('add', array(
150			new Reference($filtersOption)
151			));
152			}
153
154			$importerDef->addMethodCall('filters', array(
155			$filtersDef
156			));
157			}
158
159			private function generateTransformerDef(array $mappingOptions, Definition $importerDef)
160			{
161			$mappingsDef = new Definition('Mathielen\ImportEngine\Mapping\Mappings');
162
163			//set converters
164			foreach ($mappingOptions as $field=>$fieldMapping) {
165			$converter = null;
166			if (isset($fieldMapping['converter'])) {
167			$converter = $fieldMapping['converter'];
168			}
169
170			if (isset($fieldMapping['to'])) {
171			$mappingsDef->addMethodCall('add', array(
172			$field,
173			$fieldMapping['to'],
174			$converter
175			));
176			} elseif ($converter) {
177			$mappingsDef->addMethodCall('setConverter', array(
178			$converter,
179			$field
180			));
181			}
182			}
183
184			$mappingFactoryDef = new Definition('Mathielen\ImportEngine\Mapping\DefaultMappingFactory', array(
185			$mappingsDef
186			));
187			$converterProviderDef = new Definition('Mathielen\ImportEngine\Mapping\Converter\Provider\ContainerAwareConverterProvider', array(
188			new Reference('service_container')
189			));
190
191			$transformerDef = new Definition('Mathielen\ImportEngine\Transformation\Transformation');
192			$transformerDef->addMethodCall('setMappingFactory', array(
193			$mappingFactoryDef
194			));
195			$transformerDef->addMethodCall('setConverterProvider', array(
196			$converterProviderDef
197			));
198
199			$importerDef->addMethodCall('transformation', array(
200			$transformerDef
201			));
202			}
203
204	2		private function generateValidatorDef(array $options)
205			{
206			//eventdispatcher aware source validatorfilter
207	2		$validatorFilterDef = new Definition('Mathielen\DataImport\Filter\ValidatorFilter', array(
208	2		new Reference('validator'),
209	2		$options,
210	2		new Reference('event_dispatcher')
211	2		));
212
213	2		return $validatorFilterDef;
214			}
215
216	2		private function generateValidationDef(array $validationConfig, Definition $importerDef, Definition $objectFactoryDef=null)
217			{
218	2		$validationDef = new Definition('Mathielen\ImportEngine\Validation\ValidatorValidation', array(
219	2		new Reference('validator')
220	2		));
221	2		$importerDef->addMethodCall('validation', array(
222			$validationDef
223	2		));
224
225	2		$validatorFilterDef = $this->generateValidatorDef(
226	2		isset($validationConfig['options'])?$validationConfig['options']:array()
227	2		);
228
229	2		if (isset($validationConfig['source'])) {
230	2		$validationDef->addMethodCall('setSourceValidatorFilter', array(
231			$validatorFilterDef
232	2		));
233
234	2		foreach ($validationConfig['source']['constraints'] as $field=>$constraint) {
235	2		$validationDef->addMethodCall('addSourceConstraint', array(
236	2		$field,
237	2		new Definition($constraint)
238	2		));
239	2		}
240	2		}
241
242			//automatically apply class validation
243	2		if (isset($validationConfig['target'])) {
244
245			//using objects as result
246	2		if ($objectFactoryDef) {
247
248			//set eventdispatcher aware target CLASS-validatorfilter
249			$validatorFilterDef = new Definition('Mathielen\DataImport\Filter\ClassValidatorFilter', array(
250			new Reference('validator'),
251			$objectFactoryDef,
252			new Reference('event_dispatcher')
253			));
254
255			} else {
256	2		foreach ($validationConfig['target']['constraints'] as $field=>$constraint) {
257	2		$validationDef->addMethodCall('addTargetConstraint', array(
258	2		$field,
259	2		new Definition($constraint)
260	2		));
261	2		}
262			}
263
264	2		$validationDef->addMethodCall('setTargetValidatorFilter', array(
265			$validatorFilterDef
266	2		));
267	2		}
268
269	2		return $validationDef;
270			}
271
272			private function setSourceStorageDef(array $sourceConfig, Definition $importerDef)
273			{
274			$sDef = $this->getStorageDef($sourceConfig, $importerDef);
275			$importerDef->addMethodCall('setSourceStorage', array(
276			$sDef
277			));
278			}
279
280			private function addStorageProviderDef(Definition $storageLocatorDef, $config, $id = 'default')
281			{
282			$formatDiscoverLocalFileStorageFactoryDef = new Definition('Mathielen\ImportEngine\Storage\Factory\FormatDiscoverLocalFileStorageFactory', array(
283			new Definition('Mathielen\ImportEngine\Storage\Format\Discovery\MimeTypeDiscoverStrategy', array(
284			array(
285			'text/plain'=>new Definition('Mathielen\ImportEngine\Storage\Format\Factory\CsvAutoDelimiterFormatFactory'),
286			'text/csv'=>new Definition('Mathielen\ImportEngine\Storage\Format\Factory\CsvAutoDelimiterFormatFactory'),
287			)
288			)),
289			new Reference('logger')
290			));
291
292			switch ($config['type']) {
293			case 'directory':
294			$spFinderDef = new Definition('Symfony\Component\Finder\Finder');
295			$spFinderDef->addMethodCall('in', array(
296			$config['uri']
297			));
298			$spDef = new Definition('Mathielen\ImportEngine\Storage\Provider\FinderFileStorageProvider', array(
299			$spFinderDef,
300			$formatDiscoverLocalFileStorageFactoryDef
301			));
302			break;
303			case 'upload':
304			$spDef = new Definition('Mathielen\ImportEngine\Storage\Provider\UploadFileStorageProvider', array(
305			$config['uri'],
306			$formatDiscoverLocalFileStorageFactoryDef
307			));
308			break;
309			case 'doctrine':
310			$spDef = new Definition('Mathielen\ImportEngine\Storage\Provider\DoctrineQueryStorageProvider', array(
311			new Reference('doctrine.orm.entity_manager'),
312			$config['queries']
313			));
314			break;
315			case 'service':
316			$spDef = new Definition('Mathielen\ImportEngine\Storage\Provider\ServiceStorageProvider', array(
317			new Reference('service_container'),
318			$config['services']
319			));
320			break;
321			case 'file':
322			$spDef = new Definition('Mathielen\ImportEngine\Storage\Provider\FileStorageProvider', array(
323			$formatDiscoverLocalFileStorageFactoryDef
324			));
325			break;
326			default:
327			throw new InvalidConfigurationException('Unknown type for storage provider: '.$config['type']);
328			}
329
330			$storageLocatorDef->addMethodCall('register', array(
331			$id,
332			$spDef
333			));
334			}
335
336	4		private function getStorageFileDefinitionFromUri($uri)
337			{
338	4		if (substr($uri, 0, 2) === '@=') {
339			$uri = new Expression(substr($uri, 2));
340			}
341
342	4		return new Definition('SplFileInfo', array(
343			$uri
344	4		));
345			}
346
347			/**
348			* @return Definition
349			*/
350	4		private function getStorageDef(array $config, Definition $objectFactoryDef=null)
351			{
352	4		switch ($config['type']) {
353	4		case 'file':
354	4		$fileDef = $this->getStorageFileDefinitionFromUri($config['uri']);
355
356	4		$format = $config['format'];
357	4		$storageDef = new Definition('Mathielen\ImportEngine\Storage\LocalFileStorage', array(
358	4		$fileDef,
359	4		new Definition('Mathielen\ImportEngine\Storage\Format\\'.ucfirst($format['type'])."Format", $format['arguments'])
360	4		));
361
362	4		break;
363			case 'doctrine':
364			$storageDef = new Definition('Mathielen\ImportEngine\Storage\DoctrineStorage', array(
365			new Reference('doctrine.orm.entity_manager'),
366			$config['entity']
367			));
368
369			break;
370			case 'service':
371			$storageDef = new Definition('Mathielen\ImportEngine\Storage\ServiceStorage', array(
372			array(new Reference($config['service']), $config['method']), //callable
373			array(),
374			$objectFactoryDef //from parameter array
375			));
376
377			break;
378			default:
379			throw new InvalidConfigurationException('Unknown type for storage: '.$config['type']);
380	4		}
381
382	4		return $storageDef;
383			}
384
385	11		public function getAlias()
386			{
387	11		return 'mathielen_import_engine';
388			}
389			}
390

mathielen / ImportEngineBundle

Push — master ( ac3584...bafd7c )

generateObjectFactoryDef() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like