Loader::load() - Code Metrics - Inspection of "[DataLoader] Inject the service container" - hautelook/AliceBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — 1.x (#218)

by Eric

created 2016-05-11 12:35 UTC

Loader::load() C

↳ Parent: Loader

Complexity

Conditions	8
Paths	28

Size

Total Lines	40
Code Lines	22

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	26
CRAP Score	8

Importance

Changes	8
Bugs	4	Features	1

Metric	Value
c	8
b	4
f	1
dl	0
loc	40
ccs	26
cts	26
cp	1
rs	5.3846
cc	8
eloc	22
nc	28
nop	2
crap	8

<?php

/*
 * This file is part of the Hautelook\AliceBundle package.
 *
 * (c) Baldur Rensch <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Hautelook\AliceBundle\Alice\DataFixtures;

use Hautelook\AliceBundle\Alice\DataFixtures\Fixtures\Loader as FixturesLoader;
use Hautelook\AliceBundle\Alice\DataFixtures\Fixtures\LoaderInterface as FixturesLoaderInterface;
use Hautelook\AliceBundle\Alice\ProcessorChain;
use Nelmio\Alice\PersisterInterface;

/**
 * Bootstraps the given loader to persist the objects retrieved by the loader.
 *
 * @author Baldur Rensch <[email protected]>
 * @author Théo FIDRY <[email protected]>
 */
class Loader implements LoaderInterface
{
    /**
     * @var FixturesLoaderInterface
     */
    private $fixturesLoader;

    /**
     * @var ProcessorChain
     */
    private $processorChain;

    /**
     * @var bool
     */
    private $persistOnce;

    /**
     * @var int
     */
    private $loadingLimit;

    /**
     * @var string[]
     */
    private $errorMessages;

    /**
     * @param FixturesLoaderInterface $fixturesLoader
     * @param ProcessorChain          $processorChain
     * @param bool                    $persistOnce
     * @param int                     $loadingLimit
     */
    public function __construct(
        FixturesLoaderInterface $fixturesLoader,
        ProcessorChain $processorChain,
        $persistOnce,
        $loadingLimit
    ) {
        $this->fixturesLoader = $fixturesLoader;
        $this->processorChain = $processorChain;
        $this->persistOnce = $persistOnce;
        $this->loadingLimit = $loadingLimit;
    }

    /**
     * {@inheritdoc}
     */
    public function load(PersisterInterface $persister, array $fixturesFiles)
    {
        if ($this->fixturesLoader instanceof FixturesLoader) {
            $_persister = $this->fixturesLoader->getPersister();
            $this->fixturesLoader->setPersister($persister);
        }

        if (0 === count($fixturesFiles)) {
            return [];
        }

        $objects = [];
        $loadFileAttempts = 0;
        $normalizedFixturesFiles = $this->normalizeFixturesFiles($fixturesFiles);

        $this->errorMessages = [];
        while (true) {
            $objects = array_merge($objects, $this->tryToLoadFiles($persister, $normalizedFixturesFiles, $objects));

            if (true === $this->areAllFixturesLoaded($normalizedFixturesFiles)) {
                break;
            }

            if ($this->loadingLimit <= $loadFileAttempts) {
                throw new LoadingLimitException($this->loadingLimit, $normalizedFixturesFiles, $this->errorMessages);
            }

            ++$loadFileAttempts;
        }

        if (true === $this->persistOnce) {
            $this->persist($persister, $objects);
        }

        if (isset($_persister)) {
            $this->fixturesLoader->setPersister($_persister);
        }

        return $objects;
    }

    /**
     * @return ProcessorChain
     */
    public function getProcessorChain()
    {
        return $this->processorChain;
    }

    /**
     * {@inheritdoc}
     */
    public function getProcessors()
    {
        return $this->getProcessorChain()->getProcessors();
    }

    /**
     * {@inheritdoc}
     */
    public function getPersistOnce()
    {
        return $this->persistOnce;
    }

    /**
     * {@inheritdoc}
     */
    public function getLoadingLimit()
    {
        return $this->loadingLimit;
    }

    private function areAllFixturesLoaded(array $normalizedFixturesFiles)
    {
        foreach ($normalizedFixturesFiles as $fileRealPath => $fileHasBeenLoaded) {
            if (false === $fileHasBeenLoaded) {
                return false;
            }
        }

        return true;
    }

    /**
     * Returns an array where the key is the fixture file path and the value is the boolean false value.
     *
     * @param string[] $fixturesFiles
     *
     * @return array
     */
    private function normalizeFixturesFiles(array $fixturesFiles)
    {
        $normalizedFixturesFiles = array_flip($fixturesFiles);
        foreach ($normalizedFixturesFiles as $fileRealPath => $index) {
            $normalizedFixturesFiles[$fileRealPath] = false;
        }

        return $normalizedFixturesFiles;
    }

    /**
     * Goes through all fixtures files to try to load them one by one and specify for each if the file could
     * successfuly be loaded or not.
     *
     * @param PersisterInterface $persister
     * @param array              $normalizedFixturesFiles Array with the file real path as key and true as a value if
     *                                                    the files has been loaded.
     * @param array              $references
     *
     * @return \object[] All objects that could have been loaded.
     */
    private function tryToLoadFiles(PersisterInterface $persister, array &$normalizedFixturesFiles, array $references)
    {
        $objects = [];
        foreach ($normalizedFixturesFiles as $fixtureFilePath => $hasBeenLoaded) {
            if (true === $hasBeenLoaded) {
                continue;
            }

            try {
                $dataSet = $this->fixturesLoader->load($fixtureFilePath, $references);
                $normalizedFixturesFiles[$fixtureFilePath] = true;

                if (false === $this->persistOnce) {
                    $this->persist($persister, $dataSet);
                }

                $objects = array_merge($objects, $dataSet);
            } catch (\UnexpectedValueException $exception) {
                $this->registerErrorMessage($fixtureFilePath, $exception->getMessage());
            }
        }

        return $objects;
    }

    /**
     * Uses the Fixture persister to persist objects and calling the processors.
     *
     * @param PersisterInterface $persister
     * @param object[]           $objects
     */
    private function persist(PersisterInterface $persister, array $objects)
    {
        foreach ($this->getProcessors() as $processor) {
            foreach ($objects as $object) {
                $processor->preProcess($object);
            }
        }

        $persister->persist($objects);

        foreach ($this->getProcessors() as $processor) {
            foreach ($objects as $object) {
                $processor->postProcess($object);
            }
        }
    }

    /**
     * Registers the error message with the related fixture file.
     *
     * @param string $fixtureFilePath
     * @param string $errorMessage
     */
    private function registerErrorMessage($fixtureFilePath, $errorMessage)
    {
        if (true === empty($errorMessage)) {
            return;
        }

        if (!isset($this->errorMessages[$fixtureFilePath])) {
            $this->errorMessages[$fixtureFilePath] = [];
        }

        array_push($this->errorMessages[$fixtureFilePath], $errorMessage);
    }
}


1		<?php
2
3		/*
4		* This file is part of the Hautelook\AliceBundle package.
5		*
6		* (c) Baldur Rensch <[email protected]>
7		*
8		* For the full copyright and license information, please view the LICENSE
9		* file that was distributed with this source code.
10		*/
11
12		namespace Hautelook\AliceBundle\Alice\DataFixtures;
13
14		use Hautelook\AliceBundle\Alice\DataFixtures\Fixtures\Loader as FixturesLoader;
15		use Hautelook\AliceBundle\Alice\DataFixtures\Fixtures\LoaderInterface as FixturesLoaderInterface;
16		use Hautelook\AliceBundle\Alice\ProcessorChain;
17		use Nelmio\Alice\PersisterInterface;
18
19		/**
20		* Bootstraps the given loader to persist the objects retrieved by the loader.
21		*
22		* @author Baldur Rensch <[email protected]>
23		* @author Théo FIDRY <[email protected]>
24		*/
25		class Loader implements LoaderInterface
26		{
27		/**
28		* @var FixturesLoaderInterface
29		*/
30		private $fixturesLoader;
31
32		/**
33		* @var ProcessorChain
34		*/
35		private $processorChain;
36
37		/**
38		* @var bool
39		*/
40		private $persistOnce;
41
42		/**
43		* @var int
44		*/
45		private $loadingLimit;
46
47		/**
48		* @var string[]
49		*/
50		private $errorMessages;
51
52		/**
53		* @param FixturesLoaderInterface $fixturesLoader
54		* @param ProcessorChain $processorChain
55		* @param bool $persistOnce
56		* @param int $loadingLimit
57		*/
58	78	public function __construct(
59		FixturesLoaderInterface $fixturesLoader,
60		ProcessorChain $processorChain,
61		$persistOnce,
62		$loadingLimit
63		) {
64	78	$this->fixturesLoader = $fixturesLoader;
65	78	$this->processorChain = $processorChain;
66	78	$this->persistOnce = $persistOnce;
67	78	$this->loadingLimit = $loadingLimit;
68	78	}
69
70		/**
71		* {@inheritdoc}
72		*/
73	71	public function load(PersisterInterface $persister, array $fixturesFiles)
74		{
75	71	if ($this->fixturesLoader instanceof FixturesLoader) {
76	57	$_persister = $this->fixturesLoader->getPersister();
77	57	$this->fixturesLoader->setPersister($persister);
78	57	}
79
80	71	if (0 === count($fixturesFiles)) {
81	3	return [];
82		}
83
84	68	$objects = [];
85	68	$loadFileAttempts = 0;
86	68	$normalizedFixturesFiles = $this->normalizeFixturesFiles($fixturesFiles);
87
88	68	$this->errorMessages = [];
89	68	while (true) {
90	68	$objects = array_merge($objects, $this->tryToLoadFiles($persister, $normalizedFixturesFiles, $objects));
91
92	68	if (true === $this->areAllFixturesLoaded($normalizedFixturesFiles)) {
93	60	break;
94		}
95
96	38	if ($this->loadingLimit <= $loadFileAttempts) {
97	8	throw new LoadingLimitException($this->loadingLimit, $normalizedFixturesFiles, $this->errorMessages);
98		}
99
100	38	++$loadFileAttempts;
101	38	}
102
103	60	if (true === $this->persistOnce) {
104	6	$this->persist($persister, $objects);
105	6	}
106
107	60	if (isset($_persister)) {
108	12	$this->fixturesLoader->setPersister($_persister);
109	12	}
110
111	60	return $objects;
112		}
113
114		/**
115		* @return ProcessorChain
116		*/
117	63	public function getProcessorChain()
118		{
119	63	return $this->processorChain;
120		}
121
122		/**
123		* {@inheritdoc}
124		*/
125	63	public function getProcessors()
126		{
127	63	return $this->getProcessorChain()->getProcessors();
128		}
129
130		/**
131		* {@inheritdoc}
132		*/
133	48	public function getPersistOnce()
134		{
135	48	return $this->persistOnce;
136		}
137
138		/**
139		* {@inheritdoc}
140		*/
141	42	public function getLoadingLimit()
142		{
143	42	return $this->loadingLimit;
144		}
145
146	66	private function areAllFixturesLoaded(array $normalizedFixturesFiles)
147		{
148	66	foreach ($normalizedFixturesFiles as $fileRealPath => $fileHasBeenLoaded) {
149	66	if (false === $fileHasBeenLoaded) {
150	36	return false;
151		}
152	60	}
153
154	60	return true;
155		}
156
157		/**
158		* Returns an array where the key is the fixture file path and the value is the boolean false value.
159		*
160		* @param string[] $fixturesFiles
161		*
162		* @return array
163		*/
164	66	private function normalizeFixturesFiles(array $fixturesFiles)
165		{
166	66	$normalizedFixturesFiles = array_flip($fixturesFiles);
167	66	foreach ($normalizedFixturesFiles as $fileRealPath => $index) {
168	66	$normalizedFixturesFiles[$fileRealPath] = false;
169	66	}
170
171	66	return $normalizedFixturesFiles;
172		}
173
174		/**
175		* Goes through all fixtures files to try to load them one by one and specify for each if the file could
176		* successfuly be loaded or not.
177		*
178		* @param PersisterInterface $persister
179		* @param array $normalizedFixturesFiles Array with the file real path as key and true as a value if
180		* the files has been loaded.
181		* @param array $references
182		*
183		* @return \object[] All objects that could have been loaded.
184		*/
185	66	private function tryToLoadFiles(PersisterInterface $persister, array &$normalizedFixturesFiles, array $references)
186		{
187	66	$objects = [];
188	66	foreach ($normalizedFixturesFiles as $fixtureFilePath => $hasBeenLoaded) {
189	66	if (true === $hasBeenLoaded) {
190	30	continue;
191		}
192
193		try {
194	66	$dataSet = $this->fixturesLoader->load($fixtureFilePath, $references);
195	60	$normalizedFixturesFiles[$fixtureFilePath] = true;
196
197	60	if (false === $this->persistOnce) {
198	54	$this->persist($persister, $dataSet);
199	54	}
200
201	60	$objects = array_merge($objects, $dataSet);
202	66	} catch (\UnexpectedValueException $exception) {
203	36	$this->registerErrorMessage($fixtureFilePath, $exception->getMessage());
204		}
205	66	}
206
207	66	return $objects;
208		}
209
210		/**
211		* Uses the Fixture persister to persist objects and calling the processors.
212		*
213		* @param PersisterInterface $persister
214		* @param object[] $objects
215		*/
216	60	private function persist(PersisterInterface $persister, array $objects)
217		{
218	60	foreach ($this->getProcessors() as $processor) {
219	48	foreach ($objects as $object) {
220	48	$processor->preProcess($object);
221	48	}
222	60	}
223
224	60	$persister->persist($objects);
225
226	60	foreach ($this->getProcessors() as $processor) {
227	48	foreach ($objects as $object) {
228	48	$processor->postProcess($object);
229	48	}
230	60	}
231	60	}
232
233		/**
234		* Registers the error message with the related fixture file.
235		*
236		* @param string $fixtureFilePath
237		* @param string $errorMessage
238		*/
239	38	private function registerErrorMessage($fixtureFilePath, $errorMessage)
240		{
241	38	if (true === empty($errorMessage)) {
242	8	return;
243		}
244
245	32	if (!isset($this->errorMessages[$fixtureFilePath])) {
246	32	$this->errorMessages[$fixtureFilePath] = [];
247	32	}
248
249	32	array_push($this->errorMessages[$fixtureFilePath], $errorMessage);
250	32	}
251		}
252

hautelook / AliceBundle

GitHub Access Token became invalid

Pull Request — 1.x (#218)

Loader::load() C

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like