Loader::load() - Code Metrics - Inspection of "Add link to AliceGeneratorBundle (#229)" - hautelook/AliceBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 1.x ( ecb649...535f6c )

by Théo

created 2016-06-17 23:00 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	7
Bugs	4	Features	0

Metric	Value
c	7
b	4
f	0
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 = $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)
    {
        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);
                }

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

        return $references;
    }

    /**
     * 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	150	public function __construct(
59		FixturesLoaderInterface $fixturesLoader,
60		ProcessorChain $processorChain,
61		$persistOnce,
62		$loadingLimit
63		) {
64	150	$this->fixturesLoader = $fixturesLoader;
65	150	$this->processorChain = $processorChain;
66	150	$this->persistOnce = $persistOnce;
67	150	$this->loadingLimit = $loadingLimit;
68	150	}
69
70		/**
71		* {@inheritdoc}
72		*/
73	105	public function load(PersisterInterface $persister, array $fixturesFiles)
74		{
75	105	if ($this->fixturesLoader instanceof FixturesLoader) {
76	93	$_persister = $this->fixturesLoader->getPersister();
77	93	$this->fixturesLoader->setPersister($persister);
78	93	}
79
80	105	if (0 === count($fixturesFiles)) {
81	3	return [];
82		}
83
84	102	$objects = [];
85	102	$loadFileAttempts = 0;
86	102	$normalizedFixturesFiles = $this->normalizeFixturesFiles($fixturesFiles);
87
88	102	$this->errorMessages = [];
89	102	while (true) {
90	102	$objects = $this->tryToLoadFiles($persister, $normalizedFixturesFiles, $objects);
91
92	102	if (true === $this->areAllFixturesLoaded($normalizedFixturesFiles)) {
93	96	break;
94		}
95
96	66	if ($this->loadingLimit <= $loadFileAttempts) {
97	6	throw new LoadingLimitException($this->loadingLimit, $normalizedFixturesFiles, $this->errorMessages);
98		}
99
100	66	++$loadFileAttempts;
101	66	}
102
103	96	if (true === $this->persistOnce) {
104	6	$this->persist($persister, $objects);
105	6	}
106
107	96	if (isset($_persister)) {
108	12	$this->fixturesLoader->setPersister($_persister);
109	12	}
110
111	96	return $objects;
112		}
113
114		/**
115		* @return ProcessorChain
116		*/
117	99	public function getProcessorChain()
118		{
119	99	return $this->processorChain;
120		}
121
122		/**
123		* {@inheritdoc}
124		*/
125	99	public function getProcessors()
126		{
127	99	return $this->getProcessorChain()->getProcessors();
128		}
129
130		/**
131		* {@inheritdoc}
132		*/
133	84	public function getPersistOnce()
134		{
135	84	return $this->persistOnce;
136		}
137
138		/**
139		* {@inheritdoc}
140		*/
141	78	public function getLoadingLimit()
142		{
143	78	return $this->loadingLimit;
144		}
145
146	102	private function areAllFixturesLoaded(array $normalizedFixturesFiles)
147		{
148	102	foreach ($normalizedFixturesFiles as $fileRealPath => $fileHasBeenLoaded) {
149	102	if (false === $fileHasBeenLoaded) {
150	66	return false;
151		}
152	96	}
153
154	96	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	102	private function normalizeFixturesFiles(array $fixturesFiles)
165		{
166	102	$normalizedFixturesFiles = array_flip($fixturesFiles);
167	102	foreach ($normalizedFixturesFiles as $fileRealPath => $index) {
168	102	$normalizedFixturesFiles[$fileRealPath] = false;
169	102	}
170
171	102	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	102	private function tryToLoadFiles(PersisterInterface $persister, array &$normalizedFixturesFiles, array $references)
186		{
187	102	foreach ($normalizedFixturesFiles as $fixtureFilePath => $hasBeenLoaded) {
188	102	if (true === $hasBeenLoaded) {
189	60	continue;
190		}
191
192		try {
193	102	$dataSet = $this->fixturesLoader->load($fixtureFilePath, $references);
194	96	$normalizedFixturesFiles[$fixtureFilePath] = true;
195
196	96	if (false === $this->persistOnce) {
197	90	$this->persist($persister, $dataSet);
198	90	}
199
200	96	$references = array_merge($references, $dataSet);
201	102	} catch (\UnexpectedValueException $exception) {
202	66	$this->registerErrorMessage($fixtureFilePath, $exception->getMessage());
203		}
204	102	}
205
206	102	return $references;
207		}
208
209		/**
210		* Uses the Fixture persister to persist objects and calling the processors.
211		*
212		* @param PersisterInterface $persister
213		* @param object[] $objects
214		*/
215	96	private function persist(PersisterInterface $persister, array $objects)
216		{
217	96	foreach ($this->getProcessors() as $processor) {
218	84	foreach ($objects as $object) {
219	84	$processor->preProcess($object);
220	84	}
221	96	}
222
223	96	$persister->persist($objects);
224
225	96	foreach ($this->getProcessors() as $processor) {
226	84	foreach ($objects as $object) {
227	84	$processor->postProcess($object);
228	84	}
229	96	}
230	96	}
231
232		/**
233		* Registers the error message with the related fixture file.
234		*
235		* @param string $fixtureFilePath
236		* @param string $errorMessage
237		*/
238	66	private function registerErrorMessage($fixtureFilePath, $errorMessage)
239		{
240	66	if (true === empty($errorMessage)) {
241	6	return;
242		}
243
244	60	if (!isset($this->errorMessages[$fixtureFilePath])) {
245	60	$this->errorMessages[$fixtureFilePath] = [];
246	60	}
247
248	60	array_push($this->errorMessages[$fixtureFilePath], $errorMessage);
249	60	}
250		}
251

hautelook / AliceBundle

GitHub Access Token became invalid

Push — 1.x ( ecb649...535f6c )

Loader::load() C

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like