MathielenImportEngineExtension::getStorageFileDefinitionFromUri() - Code Metrics - Inspection of "minor fix w/ contexts" - mathielen/ImportEngineBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 8bfaf3...89e20b )

by Markus

created 2016-02-01 13:56 UTC

getStorageFileDefinitionFromUri() A

↳ Parent: MathielenImportEngineExtension

Complexity

Conditions	2
Paths	2

Size

Total Lines	10
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	2.1481

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
c	2
b	0
f	0
dl	0
loc	10
ccs	4
cts	6
cp	0.6667
rs	9.4285
cc	2
eloc	5
nc	2
nop	1
crap	2.1481

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

mathielen / ImportEngineBundle

Push — master ( 8bfaf3...89e20b )

getStorageFileDefinitionFromUri() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like