ProductAssociationContext::__construct() - Code Metrics - Inspection of "[Behat] Delete unused step definitions" - pamil/Sylius - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — unused-definitions ( d9908f )

by Kamil

created 2016-12-21 14:50 UTC

ProductAssociationContext::__construct() A

↳ Parent: ProductAssociationContext

Complexity

Conditions	1
Paths	1

Size

Total Lines	17
Code Lines	15

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	17
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	15
nc	1
nop	7

<?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 Doctrine\Common\Persistence\ObjectManager;
use Sylius\Behat\Service\SharedStorageInterface;
use Sylius\Component\Core\Model\ProductInterface;
use Sylius\Component\Product\Model\ProductAssociationInterface;
use Sylius\Component\Product\Model\ProductAssociationTypeInterface;
use Sylius\Component\Product\Model\ProductAssociationTypeTranslationInterface;
use Sylius\Component\Product\Repository\ProductAssociationTypeRepositoryInterface;
use Sylius\Component\Resource\Factory\FactoryInterface;
use Sylius\Component\Resource\Model\TranslationInterface;
use Sylius\Component\Resource\Repository\RepositoryInterface;

/**
 * @author Grzegorz Sadowski <[email protected]>
 */
final class ProductAssociationContext implements Context
{
    /**
     * @var SharedStorageInterface
     */
    private $sharedStorage;

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

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

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

    /**
     * @var ProductAssociationTypeRepositoryInterface
     */
    private $productAssociationTypeRepository;

    /**
     * @var RepositoryInterface
     */
    private $productAssociationRepository;

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

    /**
     * @param SharedStorageInterface $sharedStorage
     * @param FactoryInterface $productAssociationTypeFactory
     * @param FactoryInterface $productAssociationTypeTranslationFactory
     * @param FactoryInterface $productAssociationFactory
     * @param ProductAssociationTypeRepositoryInterface $productAssociationTypeRepository
     * @param RepositoryInterface $productAssociationRepository
     * @param ObjectManager $objectManager
     */
    public function __construct(
        SharedStorageInterface $sharedStorage,
        FactoryInterface $productAssociationTypeFactory,
        FactoryInterface $productAssociationTypeTranslationFactory,
        FactoryInterface $productAssociationFactory,
        ProductAssociationTypeRepositoryInterface $productAssociationTypeRepository,
        RepositoryInterface $productAssociationRepository,
        ObjectManager $objectManager
    ) {
        $this->sharedStorage = $sharedStorage;
        $this->productAssociationTypeFactory = $productAssociationTypeFactory;
        $this->productAssociationTypeTranslationFactory = $productAssociationTypeTranslationFactory;
        $this->productAssociationFactory = $productAssociationFactory;
        $this->productAssociationTypeRepository = $productAssociationTypeRepository;
        $this->productAssociationRepository = $productAssociationRepository;
        $this->objectManager = $objectManager;
    }

    /**
     * @Given the store has (also) a product association type :name
     * @Given the store has (also) a product association type :name with a code :code
     */
    public function theStoreHasAProductAssociationType($name, $code = null)
    {
        $this->createProductAssociationType($name, $code);
    }

    /**
     * @Given /^the store has(?:| also) a product association type named "([^"]+)" in ("[^"]+" locale) and "([^"]+)" in ("[^"]+" locale)$/
     */
    public function itHasVariantNamedInAndIn($firstName, $firstLocale, $secondName, $secondLocale)
    {
        $productAssociationType = $this->createProductAssociationType($firstName);

        $names = [$firstName => $firstLocale, $secondName => $secondLocale];
        foreach ($names as $name => $locale) {
            $this->addProductAssociationTypeTranslation($productAssociationType, $name, $locale);
        }

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

    /**
     * @Given the store has :firstName and :secondName product association types
     */
    public function theStoreHasProductAssociationTypes(...$names)
    {
        foreach ($names as $name) {
            $this->createProductAssociationType($name);
        }
    }

    /**
     * @Given /^the (product "[^"]+") has(?:| also) an (association "[^"]+") with (product "[^"]+")$/
     */
    public function theProductHasAnAssociationWithProduct(
        ProductInterface $product,
        ProductAssociationTypeInterface $productAssociationType,
        ProductInterface $associatedProduct
    ) {
        $this->createProductAssociation($product, $productAssociationType, [$associatedProduct]);
    }

    /**
     * @Given /^the (product "[^"]+") has(?:| also) an (association "[^"]+") with (products "[^"]+" and "[^"]+")$/
     */
    public function theProductHasAnAssociationWithProducts(
        ProductInterface $product,
        ProductAssociationTypeInterface $productAssociationType,
        array $associatedProducts
    ) {
        $this->createProductAssociation($product, $productAssociationType, $associatedProducts);
    }

    /**
     * @param string $name
     * @param string|null $code
     *
     * @return ProductAssociationTypeInterface
     */
    private function createProductAssociationType($name, $code = null)
    {
        if (null === $code) {
            $code = $this->generateCodeFromName($name);
        }

        /** @var ProductAssociationTypeInterface $productAssociationType */
        $productAssociationType = $this->productAssociationTypeFactory->createNew();
        $productAssociationType->setCode($code);
        $productAssociationType->setName($name);

        $this->productAssociationTypeRepository->add($productAssociationType);
        $this->sharedStorage->set('product_association_type', $productAssociationType);

        return $productAssociationType;
    }

    /**
     * @param ProductInterface $product
     * @param ProductAssociationTypeInterface $productAssociationType
     * @param array $associatedProducts
     */
    private function createProductAssociation(
        ProductInterface $product,
        ProductAssociationTypeInterface $productAssociationType,
        array $associatedProducts
    ) {
        /** @var ProductAssociationInterface $productAssociation */
        $productAssociation = $this->productAssociationFactory->createNew();
        $productAssociation->setType($productAssociationType);

        foreach ($associatedProducts as $associatedProduct) {
            $productAssociation->addAssociatedProduct($associatedProduct);
        }

        $product->addAssociation($productAssociation);

        $this->productAssociationRepository->add($productAssociation);
    }

    /**
     * @param ProductAssociationTypeInterface $productAssociationType
     * @param string $name
     * @param string $locale
     */
    private function addProductAssociationTypeTranslation(
        ProductAssociationTypeInterface $productAssociationType,
        $name,
        $locale
    ) {
        /** @var ProductAssociationTypeTranslationInterface|TranslationInterface $translation */
        $translation = $this->productAssociationTypeTranslationFactory->createNew();
        $translation->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.
}
        $translation->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.
}

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

    return array();
}

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

    /**
     * @param string $name
     *
     * @return string
     */
    private function generateCodeFromName($name)
    {
        return str_replace([' ', '-'], '_', strtolower($name));
    }
}


Push — unused-definitions ( d9908f )

ProductAssociationContext::__construct() A

Complexity

Size

Duplication

Importance

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 Doctrine\Common\Persistence\ObjectManager;
16			use Sylius\Behat\Service\SharedStorageInterface;
17			use Sylius\Component\Core\Model\ProductInterface;
18			use Sylius\Component\Product\Model\ProductAssociationInterface;
19			use Sylius\Component\Product\Model\ProductAssociationTypeInterface;
20			use Sylius\Component\Product\Model\ProductAssociationTypeTranslationInterface;
21			use Sylius\Component\Product\Repository\ProductAssociationTypeRepositoryInterface;
22			use Sylius\Component\Resource\Factory\FactoryInterface;
23			use Sylius\Component\Resource\Model\TranslationInterface;
24			use Sylius\Component\Resource\Repository\RepositoryInterface;
25
26			/**
27			* @author Grzegorz Sadowski <[email protected]>
28			*/
29			final class ProductAssociationContext implements Context
30			{
31			/**
32			* @var SharedStorageInterface
33			*/
34			private $sharedStorage;
35
36			/**
37			* @var FactoryInterface
38			*/
39			private $productAssociationTypeFactory;
40
41			/**
42			* @var FactoryInterface
43			*/
44			private $productAssociationTypeTranslationFactory;
45
46			/**
47			* @var FactoryInterface
48			*/
49			private $productAssociationFactory;
50
51			/**
52			* @var ProductAssociationTypeRepositoryInterface
53			*/
54			private $productAssociationTypeRepository;
55
56			/**
57			* @var RepositoryInterface
58			*/
59			private $productAssociationRepository;
60
61			/**
62			* @var ObjectManager
63			*/
64			private $objectManager;
65
66			/**
67			* @param SharedStorageInterface $sharedStorage
68			* @param FactoryInterface $productAssociationTypeFactory
69			* @param FactoryInterface $productAssociationTypeTranslationFactory
70			* @param FactoryInterface $productAssociationFactory
71			* @param ProductAssociationTypeRepositoryInterface $productAssociationTypeRepository
72			* @param RepositoryInterface $productAssociationRepository
73			* @param ObjectManager $objectManager
74			*/
75			public function __construct(
76			SharedStorageInterface $sharedStorage,
77			FactoryInterface $productAssociationTypeFactory,
78			FactoryInterface $productAssociationTypeTranslationFactory,
79			FactoryInterface $productAssociationFactory,
80			ProductAssociationTypeRepositoryInterface $productAssociationTypeRepository,
81			RepositoryInterface $productAssociationRepository,
82			ObjectManager $objectManager
83			) {
84			$this->sharedStorage = $sharedStorage;
85			$this->productAssociationTypeFactory = $productAssociationTypeFactory;
86			$this->productAssociationTypeTranslationFactory = $productAssociationTypeTranslationFactory;
87			$this->productAssociationFactory = $productAssociationFactory;
88			$this->productAssociationTypeRepository = $productAssociationTypeRepository;
89			$this->productAssociationRepository = $productAssociationRepository;
90			$this->objectManager = $objectManager;
91			}
92
93			/**
94			* @Given the store has (also) a product association type :name
95			* @Given the store has (also) a product association type :name with a code :code
96			*/
97			public function theStoreHasAProductAssociationType($name, $code = null)
98			{
99			$this->createProductAssociationType($name, $code);
100			}
101
102			/**
103			* @Given /^the store has(?:\| also) a product association type named "([^"]+)" in ("[^"]+" locale) and "([^"]+)" in ("[^"]+" locale)$/
104			*/
105			public function itHasVariantNamedInAndIn($firstName, $firstLocale, $secondName, $secondLocale)
106			{
107			$productAssociationType = $this->createProductAssociationType($firstName);
108
109			$names = [$firstName => $firstLocale, $secondName => $secondLocale];
110			foreach ($names as $name => $locale) {
111			$this->addProductAssociationTypeTranslation($productAssociationType, $name, $locale);
112			}
113
114			$this->objectManager->flush();
115			}
116
117			/**
118			* @Given the store has :firstName and :secondName product association types
119			*/
120			public function theStoreHasProductAssociationTypes(...$names)
121			{
122			foreach ($names as $name) {
123			$this->createProductAssociationType($name);
124			}
125			}
126
127			/**
128			* @Given /^the (product "[^"]+") has(?:\| also) an (association "[^"]+") with (product "[^"]+")$/
129			*/
130			public function theProductHasAnAssociationWithProduct(
131			ProductInterface $product,
132			ProductAssociationTypeInterface $productAssociationType,
133			ProductInterface $associatedProduct
134			) {
135			$this->createProductAssociation($product, $productAssociationType, [$associatedProduct]);
136			}
137
138			/**
139			* @Given /^the (product "[^"]+") has(?:\| also) an (association "[^"]+") with (products "[^"]+" and "[^"]+")$/
140			*/
141			public function theProductHasAnAssociationWithProducts(
142			ProductInterface $product,
143			ProductAssociationTypeInterface $productAssociationType,
144			array $associatedProducts
145			) {
146			$this->createProductAssociation($product, $productAssociationType, $associatedProducts);
147			}
148
149			/**
150			* @param string $name
151			* @param string\|null $code
152			*
153			* @return ProductAssociationTypeInterface
154			*/
155			private function createProductAssociationType($name, $code = null)
156			{
157			if (null === $code) {
158			$code = $this->generateCodeFromName($name);
159			}
160
161			/** @var ProductAssociationTypeInterface $productAssociationType */
162			$productAssociationType = $this->productAssociationTypeFactory->createNew();
163			$productAssociationType->setCode($code);
164			$productAssociationType->setName($name);
165
166			$this->productAssociationTypeRepository->add($productAssociationType);
167			$this->sharedStorage->set('product_association_type', $productAssociationType);
168
169			return $productAssociationType;
170			}
171
172			/**
173			* @param ProductInterface $product
174			* @param ProductAssociationTypeInterface $productAssociationType
175			* @param array $associatedProducts
176			*/
177			private function createProductAssociation(
178			ProductInterface $product,
179			ProductAssociationTypeInterface $productAssociationType,
180			array $associatedProducts
181			) {
182			/** @var ProductAssociationInterface $productAssociation */
183			$productAssociation = $this->productAssociationFactory->createNew();
184			$productAssociation->setType($productAssociationType);
185
186			foreach ($associatedProducts as $associatedProduct) {
187			$productAssociation->addAssociatedProduct($associatedProduct);
188			}
189
190			$product->addAssociation($productAssociation);
191
192			$this->productAssociationRepository->add($productAssociation);
193			}
194
195			/**
196			* @param ProductAssociationTypeInterface $productAssociationType
197			* @param string $name
198			* @param string $locale
199			*/
200			private function addProductAssociationTypeTranslation(
201			ProductAssociationTypeInterface $productAssociationType,
202			$name,
203			$locale
204			) {
205			/** @var ProductAssociationTypeTranslationInterface\|TranslationInterface $translation */
206			$translation = $this->productAssociationTypeTranslationFactory->createNew();
207			$translation->setLocale($locale);
			0 ignored issues – show Bug introduced 2016-12-21 15:08 UTC by Report Bug Copy Issue Report The method `setLocale` does only exist in `Sylius\Component\Resourc...el\TranslationInterface`, but not in `Sylius\Component\Product...ypeTranslationInterface`. 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...
208			$translation->setName($name);
			0 ignored issues – show Bug introduced 2016-12-21 15:08 UTC by Report Bug Copy Issue Report The method `setName` does only exist in `Sylius\Component\Product...ypeTranslationInterface`, 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...
209
210			$productAssociationType->addTranslation($translation);
			0 ignored issues – show Bug introduced 2016-12-21 15:08 UTC by Report Bug Copy Issue Report It seems like `$translation` defined by `$this->productAssociatio...ionFactory->createNew()` on line `206` can also be of type `object<Sylius\Component\...peTranslationInterface>`; 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...
211			}
212
213			/**
214			* @param string $name
215			*
216			* @return string
217			*/
218			private function generateCodeFromName($name)
219			{
220			return str_replace([' ', '-'], '_', strtolower($name));
221			}
222			}
223

pamil / Sylius

Push — unused-definitions ( d9908f )

ProductAssociationContext::__construct() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like