AbstractAliceContext::loadFixtures() - Code Metrics - theofidry/AliceBundleExtension - Measure and Improve Code Quality continuously with Scrutinizer

AbstractAliceContext::loadFixtures() C
last analyzed 2016-09-02 14:47 UTC

↳ Parent: AbstractAliceContext

Complexity

Conditions	10
Paths	96

Size

Total Lines	54
Code Lines	30

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	1

Metric	Value
c	2
b	0
f	1
dl	0
loc	54
rs	6.8372
cc	10
eloc	30
nc	96
nop	2

How to fix Long Method Complexity

<?php

/*
 * This file is part of the Fidry\AliceBundleExtension package.
 *
 * (c) Théo FIDRY <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Fidry\AliceBundleExtension\Context\Doctrine;

use Behat\Gherkin\Node\TableNode;
use Behat\Symfony2Extension\Context\KernelAwareContext;
use Doctrine\Common\Persistence\ObjectManager;
use Fidry\AliceBundleExtension\Context\AliceContextInterface;
use Hautelook\AliceBundle\Alice\DataFixtures\LoaderInterface;
use Hautelook\AliceBundle\Finder\FixturesFinderInterface;
use Nelmio\Alice\Persister\Doctrine;
use Nelmio\Alice\PersisterInterface;
use Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException;
use Symfony\Component\HttpKernel\KernelInterface;

/**
 * Context to load fixtures files with Alice loader.
 *
 * @author Théo FIDRY <[email protected]>
 */
abstract class AbstractAliceContext implements KernelAwareContext, AliceContextInterface
{
    /**
     * @var string
     */
    protected $basePath;

    /**
     * @var string[]
     */
    protected $classes;

    /**
     * @var FixturesFinderInterface
     */
    protected $fixturesFinder;

    /**
     * @var KernelInterface
     */
    protected $kernel;

    /**
     * @var LoaderInterface
     */
    protected $loader;

    /**
     * @var PersisterInterface
     */
    protected $persister;

    /**
     * @param string|null $basePath
     */
    public function __construct($basePath = null)
    {
        $this->basePath = $basePath;
    }

    /**
     * @param KernelInterface                  $kernel
     * @param FixturesFinderInterface          $fixturesFinder
     * @param LoaderInterface                  $loader
     * @param PersisterInterface|ObjectManager $persister
     * @param string                           $basePath
     */
    final public function init(
        KernelInterface $kernel,
        FixturesFinderInterface $fixturesFinder,
        LoaderInterface $loader,
        PersisterInterface $persister,
        $basePath = null
    ) {
        $this->kernel = $kernel;
        $this->fixturesFinder = $fixturesFinder;
        $this->loader = $loader;
        $this->persister = $persister;

        if (null !== $basePath) {
            $this->basePath = $basePath;
        }
    }

    /**
     * {@inheritdoc}
     *
     * @return $this
     */
    abstract public function setKernel(KernelInterface $kernel);

    /**
     * {@inheritdoc}
     */
    final public function setBasePath($basePath)
    {
        $this->basePath = $basePath;

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    final public function getBasePath()
    {
        return $this->basePath;
    }

    /**
     * @Transform /^service$/
     *
     * @throws ServiceNotFoundException
     */
    public function castServiceIdToService($serviceId)
    {
        return $this->kernel->getContainer()->get($serviceId);
    }

    /**
     * @Transform /^persister$/
     *
     * @throws ServiceNotFoundException
     */
    public function castServiceIdToPersister($serviceId)
    {
        $service = $this->castServiceIdToService($serviceId);

        return $this->resolvePersister($service);
    }

    /**
     * {@inheritdoc}
     */
    public function thereAreFixtures($fixturesFile, $persister = null)
    {
        $this->loadFixtures([$fixturesFile], $persister);
    }

    /**
     * {@inheritdoc}
     */
    public function thereAreSeveralFixtures(TableNode $fixturesFileRows, $persister = null)
    {
        $fixturesFiles = [];

        foreach ($fixturesFileRows->getRows() as $fixturesFileRow) {
            $fixturesFiles[] = $fixturesFileRow[0];
        }

        $this->loadFixtures($fixturesFiles, $persister);
    }

    /**
     * @param array              $fixturesFiles
     * @param PersisterInterface $persister
     */
    private function loadFixtures($fixturesFiles, $persister = null)
    {
        if (null === $persister) {
            $persister = $this->persister;
        }

        if (true === is_string($persister)) {
            $persister = $this->castServiceIdToPersister($persister);
        }

        $fixtureBundles = [];
        $fixtureDirectories = [];

        foreach ($fixturesFiles as $key => $fixturesFile) {
            if (0 === strpos($fixturesFile, '/')) {
                if (is_dir($fixturesFile)) {
                    $fixtureDirectories[] = $fixturesFile;
                    unset($fixturesFiles[$key]);
                }

                continue;
            }

            if (0 === strpos($fixturesFile, '@')) {
                if (false === strpos($fixturesFile, '.')) {
                    $fixtureBundles[] = $this->kernel->getBundle(substr($fixturesFile, 1));
                    unset($fixturesFiles[$key]);
                }

                continue;
            }

            $fixturesFiles[$key] = sprintf('%s/%s', $this->basePath, $fixturesFile);
        }

        if (false === empty($fixtureBundles)) {
            $fixturesFiles = array_merge(
                $fixturesFiles,
                $this->fixturesFinder->getFixtures($this->kernel, $fixtureBundles, $this->kernel->getEnvironment())
            );
        }

        if (false === empty($fixtureDirectories)) {
            $fixturesFiles = array_merge(
                $fixturesFiles,
                $this->fixturesFinder->getFixturesFromDirectory($fixtureDirectories)
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            );
        }

        $this->loader->load(
            $persister,
            $this->fixturesFinder->resolveFixtures($this->kernel, $fixturesFiles)
        );
    }

    /**
     * @param Doctrine|PersisterInterface|null $persister
     *
     * @return PersisterInterface
     *
     * @throws \InvalidArgumentException
     */
    final protected function resolvePersister($persister)
    {
        if (null === $persister) {
            return $this->persister;
        }

        switch (true) {
            case $persister instanceof PersisterInterface:
                return $persister;
            case $persister instanceof ObjectManager:
                return new Doctrine($persister);

            default:
                throw new \InvalidArgumentException(sprintf(
                    'Invalid persister type, expected Nelmio\Alice\PersisterInterface or Doctrine\Common\Persistence\ObjectManager. Got %s instead.',
                    get_class($persister)
                ));
        }
    }
}


1			<?php
2
3			/*
4			* This file is part of the Fidry\AliceBundleExtension package.
5			*
6			* (c) Théo FIDRY <[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 Fidry\AliceBundleExtension\Context\Doctrine;
13
14			use Behat\Gherkin\Node\TableNode;
15			use Behat\Symfony2Extension\Context\KernelAwareContext;
16			use Doctrine\Common\Persistence\ObjectManager;
17			use Fidry\AliceBundleExtension\Context\AliceContextInterface;
18			use Hautelook\AliceBundle\Alice\DataFixtures\LoaderInterface;
19			use Hautelook\AliceBundle\Finder\FixturesFinderInterface;
20			use Nelmio\Alice\Persister\Doctrine;
21			use Nelmio\Alice\PersisterInterface;
22			use Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException;
23			use Symfony\Component\HttpKernel\KernelInterface;
24
25			/**
26			* Context to load fixtures files with Alice loader.
27			*
28			* @author Théo FIDRY <[email protected]>
29			*/
30			abstract class AbstractAliceContext implements KernelAwareContext, AliceContextInterface
31			{
32			/**
33			* @var string
34			*/
35			protected $basePath;
36
37			/**
38			* @var string[]
39			*/
40			protected $classes;
41
42			/**
43			* @var FixturesFinderInterface
44			*/
45			protected $fixturesFinder;
46
47			/**
48			* @var KernelInterface
49			*/
50			protected $kernel;
51
52			/**
53			* @var LoaderInterface
54			*/
55			protected $loader;
56
57			/**
58			* @var PersisterInterface
59			*/
60			protected $persister;
61
62			/**
63			* @param string\|null $basePath
64			*/
65			public function __construct($basePath = null)
66			{
67			$this->basePath = $basePath;
68			}
69
70			/**
71			* @param KernelInterface $kernel
72			* @param FixturesFinderInterface $fixturesFinder
73			* @param LoaderInterface $loader
74			* @param PersisterInterface\|ObjectManager $persister
75			* @param string $basePath
76			*/
77			final public function init(
78			KernelInterface $kernel,
79			FixturesFinderInterface $fixturesFinder,
80			LoaderInterface $loader,
81			PersisterInterface $persister,
82			$basePath = null
83			) {
84			$this->kernel = $kernel;
85			$this->fixturesFinder = $fixturesFinder;
86			$this->loader = $loader;
87			$this->persister = $persister;
88
89			if (null !== $basePath) {
90			$this->basePath = $basePath;
91			}
92			}
93
94			/**
95			* {@inheritdoc}
96			*
97			* @return $this
98			*/
99			abstract public function setKernel(KernelInterface $kernel);
100
101			/**
102			* {@inheritdoc}
103			*/
104			final public function setBasePath($basePath)
105			{
106			$this->basePath = $basePath;
107
108			return $this;
109			}
110
111			/**
112			* {@inheritdoc}
113			*/
114			final public function getBasePath()
115			{
116			return $this->basePath;
117			}
118
119			/**
120			* @Transform /^service$/
121			*
122			* @throws ServiceNotFoundException
123			*/
124			public function castServiceIdToService($serviceId)
125			{
126			return $this->kernel->getContainer()->get($serviceId);
127			}
128
129			/**
130			* @Transform /^persister$/
131			*
132			* @throws ServiceNotFoundException
133			*/
134			public function castServiceIdToPersister($serviceId)
135			{
136			$service = $this->castServiceIdToService($serviceId);
137
138			return $this->resolvePersister($service);
139			}
140
141			/**
142			* {@inheritdoc}
143			*/
144			public function thereAreFixtures($fixturesFile, $persister = null)
145			{
146			$this->loadFixtures([$fixturesFile], $persister);
147			}
148
149			/**
150			* {@inheritdoc}
151			*/
152			public function thereAreSeveralFixtures(TableNode $fixturesFileRows, $persister = null)
153			{
154			$fixturesFiles = [];
155
156			foreach ($fixturesFileRows->getRows() as $fixturesFileRow) {
157			$fixturesFiles[] = $fixturesFileRow[0];
158			}
159
160			$this->loadFixtures($fixturesFiles, $persister);
161			}
162
163			/**
164			* @param array $fixturesFiles
165			* @param PersisterInterface $persister
166			*/
167			private function loadFixtures($fixturesFiles, $persister = null)
168			{
169			if (null === $persister) {
170			$persister = $this->persister;
171			}
172
173			if (true === is_string($persister)) {
174			$persister = $this->castServiceIdToPersister($persister);
175			}
176
177			$fixtureBundles = [];
178			$fixtureDirectories = [];
179
180			foreach ($fixturesFiles as $key => $fixturesFile) {
181			if (0 === strpos($fixturesFile, '/')) {
182			if (is_dir($fixturesFile)) {
183			$fixtureDirectories[] = $fixturesFile;
184			unset($fixturesFiles[$key]);
185			}
186
187			continue;
188			}
189
190			if (0 === strpos($fixturesFile, '@')) {
191			if (false === strpos($fixturesFile, '.')) {
192			$fixtureBundles[] = $this->kernel->getBundle(substr($fixturesFile, 1));
193			unset($fixturesFiles[$key]);
194			}
195
196			continue;
197			}
198
199			$fixturesFiles[$key] = sprintf('%s/%s', $this->basePath, $fixturesFile);
200			}
201
202			if (false === empty($fixtureBundles)) {
203			$fixturesFiles = array_merge(
204			$fixturesFiles,
205			$this->fixturesFinder->getFixtures($this->kernel, $fixtureBundles, $this->kernel->getEnvironment())
206			);
207			}
208
209			if (false === empty($fixtureDirectories)) {
210			$fixturesFiles = array_merge(
211			$fixturesFiles,
212			$this->fixturesFinder->getFixturesFromDirectory($fixtureDirectories)
			0 ignored issues – show Documentation introduced 2016-05-09 21:23 UTC by Report Bug Copy Issue Report `$fixtureDirectories` is of type `array`, but the function expects a `string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
213			);
214			}
215
216			$this->loader->load(
217			$persister,
218			$this->fixturesFinder->resolveFixtures($this->kernel, $fixturesFiles)
219			);
220			}
221
222			/**
223			* @param Doctrine\|PersisterInterface\|null $persister
224			*
225			* @return PersisterInterface
226			*
227			* @throws \InvalidArgumentException
228			*/
229			final protected function resolvePersister($persister)
230			{
231			if (null === $persister) {
232			return $this->persister;
233			}
234
235			switch (true) {
236			case $persister instanceof PersisterInterface:
237			return $persister;
238			case $persister instanceof ObjectManager:
239			return new Doctrine($persister);
240
241			default:
242			throw new \InvalidArgumentException(sprintf(
243			'Invalid persister type, expected Nelmio\Alice\PersisterInterface or Doctrine\Common\Persistence\ObjectManager. Got %s instead.',
244			get_class($persister)
245			));
246			}
247			}
248			}
249

theofidry / AliceBundleExtension

AbstractAliceContext::loadFixtures() C last analyzed 2016-09-02 14:47 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like

AbstractAliceContext::loadFixtures() C
last analyzed 2016-09-02 14:47 UTC