TaxonomyContext::theTaxonHasAnImageWithType() - Code Metrics - Inspection of "Merge pull request #7399 from TheMadeleine/docs/re..." - pamil/Sylius - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( cfac17...1a301c )

by Kamil

created 2017-02-07 11:51 UTC

TaxonomyContext::theTaxonHasAnImageWithType() A

↳ Parent: TaxonomyContext

Complexity

Conditions	1
Paths	1

Size

Total Lines	14
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	14
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	8
nc	1
nop	3

<?php

/*
 * This file is part of the Sylius package.
 *
 * (c) Paweł Jędrzejewski
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Sylius\Behat\Context\Setup;

use Behat\Behat\Context\Context;
use Behat\Mink\Element\NodeElement;
use Doctrine\Common\Persistence\ObjectManager;
use Sylius\Component\Core\Formatter\StringInflector;
use Sylius\Component\Core\Model\ImageInterface;
use Sylius\Component\Core\Model\TaxonInterface;
use Sylius\Component\Core\Uploader\ImageUploaderInterface;
use Sylius\Component\Resource\Factory\FactoryInterface;
use Sylius\Component\Resource\Model\TranslationInterface;
use Sylius\Component\Resource\Repository\RepositoryInterface;
use Sylius\Component\Taxonomy\Generator\TaxonSlugGeneratorInterface;
use Sylius\Component\Taxonomy\Model\TaxonTranslationInterface;
use Symfony\Component\HttpFoundation\File\UploadedFile;

/**
 * @author Mateusz Zalewski <[email protected]>
 */
final class TaxonomyContext implements Context
{
    /**
     * @var RepositoryInterface
     */
    private $taxonRepository;

    /**
     * @var FactoryInterface
     */
    private $taxonFactory;

    /**
     * @var FactoryInterface
     */
    private $taxonTranslationFactory;

    /**
     * @var FactoryInterface
     */
    private $taxonImageFactory;

    /**
     * @var ObjectManager
     */
    private $objectManager;

    /**
     * @var ImageUploaderInterface
     */
    private $imageUploader;

    /**
     * @var TaxonSlugGeneratorInterface
     */
    private $taxonSlugGenerator;

    /**
     * @var array
     */
    private $minkParameters;

    /**
     * @param RepositoryInterface $taxonRepository
     * @param FactoryInterface $taxonFactory
     * @param FactoryInterface $taxonTranslationFactory
     * @param FactoryInterface $taxonImageFactory
     * @param ObjectManager $objectManager
     * @param ImageUploaderInterface $imageUploader
     * @param TaxonSlugGeneratorInterface $taxonSlugGenerator
     * @param array $minkParameters
     */
    public function __construct(
        RepositoryInterface $taxonRepository,
        FactoryInterface $taxonFactory,
        FactoryInterface $taxonTranslationFactory,
        FactoryInterface $taxonImageFactory,
        ObjectManager $objectManager,
        ImageUploaderInterface $imageUploader,
        TaxonSlugGeneratorInterface $taxonSlugGenerator,
        array $minkParameters
    ) {
        $this->taxonRepository = $taxonRepository;
        $this->taxonFactory = $taxonFactory;
        $this->taxonTranslationFactory = $taxonTranslationFactory;
        $this->taxonImageFactory = $taxonImageFactory;
        $this->objectManager = $objectManager;
        $this->imageUploader = $imageUploader;
        $this->taxonSlugGenerator = $taxonSlugGenerator;
        $this->minkParameters = $minkParameters;
    }

    /**
     * @Given the store has :firstTaxonName taxonomy
     * @Given the store classifies its products as :firstTaxonName
     * @Given the store classifies its products as :firstTaxonName and :secondTaxonName
     * @Given the store classifies its products as :firstTaxonName, :secondTaxonName and :thirdTaxonName
     * @Given the store classifies its products as :firstTaxonName, :secondTaxonName, :thirdTaxonName and :fourthTaxonName
     */
    public function storeClassifiesItsProductsAs(...$taxonsNames)
    {
        foreach ($taxonsNames as $taxonName) {
            $this->taxonRepository->add($this->createTaxon($taxonName));
        }
    }

    /**
     * @Given /^the store has taxonomy named "([^"]+)" in ("[^"]+" locale) and "([^"]+)" in ("[^"]+" locale)$/
     */
    public function theStoreHasTaxonomyNamedInAndIn($firstName, $firstLocale, $secondName, $secondLocale)
    {
        $translationMap = [
            $firstLocale => $firstName,
            $secondLocale => $secondName,
        ];

        $this->taxonRepository->add($this->createTaxonInManyLanguages($translationMap));
    }

    /**
     * @Given /^the ("[^"]+" taxon)(?:| also) has an image "([^"]+)" with "([^"]+)" type$/
     */
    public function theTaxonHasAnImageWithType(TaxonInterface $taxon, $imagePath, $imageType)
    {
        $filesPath = $this->getParameter('files_path');

        /** @var ImageInterface $taxonImage */
        $taxonImage = $this->taxonImageFactory->createNew();
        $taxonImage->setFile(new UploadedFile($filesPath.$imagePath, basename($imagePath)));
        $taxonImage->setType($imageType);
        $this->imageUploader->upload($taxonImage);

        $taxon->addImage($taxonImage);

        $this->objectManager->flush($taxon);
    }

    /**
     * @param string $name
     *
     * @return TaxonInterface
     */
    private function createTaxon($name)
    {
        /** @var TaxonInterface $taxon */
        $taxon = $this->taxonFactory->createNew();
        $taxon->setName($name);
        $taxon->setCode(StringInflector::nameToCode($name));
        $taxon->setSlug($this->taxonSlugGenerator->generate($name));

        return $taxon;
    }

    /**
     * @param array $names
     *
     * @return TaxonInterface
     */
    private function createTaxonInManyLanguages(array $names)
    {
        /** @var TaxonInterface $taxon */
        $taxon = $this->taxonFactory->createNew();
        $taxon->setCode(StringInflector::nameToCode($names['en_US']));
        foreach ($names as $locale => $name) {
            /** @var TranslationInterface|TaxonTranslationInterface $taxonTranslation */
            $taxonTranslation = $this->taxonTranslationFactory->createNew();
            $taxonTranslation->setLocale($locale);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            $taxonTranslation->setName($name);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            $taxonTranslation->setSlug($this->taxonSlugGenerator->generate($name));
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

            $taxon->addTranslation($taxonTranslation);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        }

        return $taxon;
    }

    /**
     * @param string $name
     *
     * @return NodeElement
     */
    private function getParameter($name)
    {
        return isset($this->minkParameters[$name]) ? $this->minkParameters[$name] : null;
    }
}


Push — master ( cfac17...1a301c )

TaxonomyContext::theTaxonHasAnImageWithType() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

1			<?php
2
3			/*
4			* This file is part of the Sylius package.
5			*
6			* (c) Paweł Jędrzejewski
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 Sylius\Behat\Context\Setup;
13
14			use Behat\Behat\Context\Context;
15			use Behat\Mink\Element\NodeElement;
16			use Doctrine\Common\Persistence\ObjectManager;
17			use Sylius\Component\Core\Formatter\StringInflector;
18			use Sylius\Component\Core\Model\ImageInterface;
19			use Sylius\Component\Core\Model\TaxonInterface;
20			use Sylius\Component\Core\Uploader\ImageUploaderInterface;
21			use Sylius\Component\Resource\Factory\FactoryInterface;
22			use Sylius\Component\Resource\Model\TranslationInterface;
23			use Sylius\Component\Resource\Repository\RepositoryInterface;
24			use Sylius\Component\Taxonomy\Generator\TaxonSlugGeneratorInterface;
25			use Sylius\Component\Taxonomy\Model\TaxonTranslationInterface;
26			use Symfony\Component\HttpFoundation\File\UploadedFile;
27
28			/**
29			* @author Mateusz Zalewski <[email protected]>
30			*/
31			final class TaxonomyContext implements Context
32			{
33			/**
34			* @var RepositoryInterface
35			*/
36			private $taxonRepository;
37
38			/**
39			* @var FactoryInterface
40			*/
41			private $taxonFactory;
42
43			/**
44			* @var FactoryInterface
45			*/
46			private $taxonTranslationFactory;
47
48			/**
49			* @var FactoryInterface
50			*/
51			private $taxonImageFactory;
52
53			/**
54			* @var ObjectManager
55			*/
56			private $objectManager;
57
58			/**
59			* @var ImageUploaderInterface
60			*/
61			private $imageUploader;
62
63			/**
64			* @var TaxonSlugGeneratorInterface
65			*/
66			private $taxonSlugGenerator;
67
68			/**
69			* @var array
70			*/
71			private $minkParameters;
72
73			/**
74			* @param RepositoryInterface $taxonRepository
75			* @param FactoryInterface $taxonFactory
76			* @param FactoryInterface $taxonTranslationFactory
77			* @param FactoryInterface $taxonImageFactory
78			* @param ObjectManager $objectManager
79			* @param ImageUploaderInterface $imageUploader
80			* @param TaxonSlugGeneratorInterface $taxonSlugGenerator
81			* @param array $minkParameters
82			*/
83			public function __construct(
84			RepositoryInterface $taxonRepository,
85			FactoryInterface $taxonFactory,
86			FactoryInterface $taxonTranslationFactory,
87			FactoryInterface $taxonImageFactory,
88			ObjectManager $objectManager,
89			ImageUploaderInterface $imageUploader,
90			TaxonSlugGeneratorInterface $taxonSlugGenerator,
91			array $minkParameters
92			) {
93			$this->taxonRepository = $taxonRepository;
94			$this->taxonFactory = $taxonFactory;
95			$this->taxonTranslationFactory = $taxonTranslationFactory;
96			$this->taxonImageFactory = $taxonImageFactory;
97			$this->objectManager = $objectManager;
98			$this->imageUploader = $imageUploader;
99			$this->taxonSlugGenerator = $taxonSlugGenerator;
100			$this->minkParameters = $minkParameters;
101			}
102
103			/**
104			* @Given the store has :firstTaxonName taxonomy
105			* @Given the store classifies its products as :firstTaxonName
106			* @Given the store classifies its products as :firstTaxonName and :secondTaxonName
107			* @Given the store classifies its products as :firstTaxonName, :secondTaxonName and :thirdTaxonName
108			* @Given the store classifies its products as :firstTaxonName, :secondTaxonName, :thirdTaxonName and :fourthTaxonName
109			*/
110			public function storeClassifiesItsProductsAs(...$taxonsNames)
111			{
112			foreach ($taxonsNames as $taxonName) {
113			$this->taxonRepository->add($this->createTaxon($taxonName));
114			}
115			}
116
117			/**
118			* @Given /^the store has taxonomy named "([^"]+)" in ("[^"]+" locale) and "([^"]+)" in ("[^"]+" locale)$/
119			*/
120			public function theStoreHasTaxonomyNamedInAndIn($firstName, $firstLocale, $secondName, $secondLocale)
121			{
122			$translationMap = [
123			$firstLocale => $firstName,
124			$secondLocale => $secondName,
125			];
126
127			$this->taxonRepository->add($this->createTaxonInManyLanguages($translationMap));
128			}
129
130			/**
131			* @Given /^the ("[^"]+" taxon)(?:\| also) has an image "([^"]+)" with "([^"]+)" type$/
132			*/
133			public function theTaxonHasAnImageWithType(TaxonInterface $taxon, $imagePath, $imageType)
134			{
135			$filesPath = $this->getParameter('files_path');
136
137			/** @var ImageInterface $taxonImage */
138			$taxonImage = $this->taxonImageFactory->createNew();
139			$taxonImage->setFile(new UploadedFile($filesPath.$imagePath, basename($imagePath)));
140			$taxonImage->setType($imageType);
141			$this->imageUploader->upload($taxonImage);
142
143			$taxon->addImage($taxonImage);
144
145			$this->objectManager->flush($taxon);
146			}
147
148			/**
149			* @param string $name
150			*
151			* @return TaxonInterface
152			*/
153			private function createTaxon($name)
154			{
155			/** @var TaxonInterface $taxon */
156			$taxon = $this->taxonFactory->createNew();
157			$taxon->setName($name);
158			$taxon->setCode(StringInflector::nameToCode($name));
159			$taxon->setSlug($this->taxonSlugGenerator->generate($name));
160
161			return $taxon;
162			}
163
164			/**
165			* @param array $names
166			*
167			* @return TaxonInterface
168			*/
169			private function createTaxonInManyLanguages(array $names)
170			{
171			/** @var TaxonInterface $taxon */
172			$taxon = $this->taxonFactory->createNew();
173			$taxon->setCode(StringInflector::nameToCode($names['en_US']));
174			foreach ($names as $locale => $name) {
175			/** @var TranslationInterface\|TaxonTranslationInterface $taxonTranslation */
176			$taxonTranslation = $this->taxonTranslationFactory->createNew();
177			$taxonTranslation->setLocale($locale);
			0 ignored issues – show Bug introduced 2017-02-07 12:11 UTC by Report Bug Copy Issue Report The method `setLocale` does only exist in `Sylius\Component\Resourc...el\TranslationInterface`, but not in `Sylius\Component\Taxonom...xonTranslationInterface`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
178			$taxonTranslation->setName($name);
			0 ignored issues – show Bug introduced 2017-02-07 12:11 UTC by Report Bug Copy Issue Report The method `setName` does only exist in `Sylius\Component\Taxonom...xonTranslationInterface`, but not in `Sylius\Component\Resourc...el\TranslationInterface`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
179			$taxonTranslation->setSlug($this->taxonSlugGenerator->generate($name));
			0 ignored issues – show Bug introduced 2017-02-07 12:11 UTC by Report Bug Copy Issue Report The method `setSlug` does only exist in `Sylius\Component\Taxonom...xonTranslationInterface`, but not in `Sylius\Component\Resourc...el\TranslationInterface`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
180
181			$taxon->addTranslation($taxonTranslation);
			0 ignored issues – show Bug introduced 2017-02-07 12:11 UTC by Report Bug Copy Issue Report It seems like `$taxonTranslation` defined by `$this->taxonTranslationFactory->createNew()` on line `176` can also be of type `object<Sylius\Component\...onTranslationInterface>`; however, `Sylius\Component\Resourc...rface::addTranslation()` does only seem to accept `object<Sylius\Component\...l\TranslationInterface>`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
182			}
183
184			return $taxon;
185			}
186
187			/**
188			* @param string $name
189			*
190			* @return NodeElement
191			*/
192			private function getParameter($name)
193			{
194			return isset($this->minkParameters[$name]) ? $this->minkParameters[$name] : null;
195			}
196			}
197

pamil / Sylius

Push — master ( cfac17...1a301c )

TaxonomyContext::theTaxonHasAnImageWithType() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like