RootPackageFileManagerImpl - Code Metrics - Inspection of "Merge pull request #39 from webmozart/fix-empty-pa..." - puli/manager - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( fa0673...7f3713 )

by Bernhard

created 2016-01-04 12:29 UTC

RootPackageFileManagerImpl C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	486
Duplicated Lines	34.77 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

97.22%

Importance

Changes	7
Bugs	0	Features	5

Metric	Value
wmc	75
c	7
b	0
f	5
lcom	1
cbo	6
dl	169
loc	486
ccs	210
cts	216
cp	0.9722
rs	5.5056

27 Methods

Rating	Name	Duplication	Size	Complexity
A	getConfig()	0	4	1
A	getContext()	0	4	1
A	getPackageFile()	0	4	1
A	getPackageName()	0	4	1
A	setPackageName()	18	18	3
B	removePluginClasses()	24	24	5
A	findPluginClasses()	0	12	3
B	setExtraKey()	0	23	4
A	hasExtraKey()	0	4	1
A	hasExtraKeys()	14	14	4
A	getExtraKeys()	0	4	1
A	findExtraKeys()	0	12	3
A	migrate()	18	18	3
A	saveConfigFile()	0	4	1
A	__construct()	0	6	1
A	removePluginClass()	0	18	3
A	clearPluginClasses()	0	4	1
A	hasPluginClass()	0	4	1
A	hasPluginClasses()	14	14	4
A	getPluginClasses()	0	4	1
D	setExtraKeys()	0	35	9
A	removeExtraKey()	18	18	3
B	removeExtraKeys()	24	24	5
A	clearExtraKeys()	18	18	3
A	getExtraKey()	0	4	1
A	addPluginClass()	21	21	3
C	validatePluginClass()	0	42	8

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like RootPackageFileManagerImpl often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use RootPackageFileManagerImpl, and based on these observations, apply Extract Interface, too.

<?php

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

namespace Puli\Manager\Package;

use Exception;
use InvalidArgumentException;
use Puli\Manager\Api\Context\ProjectContext;
use Puli\Manager\Api\Package\RootPackageFile;
use Puli\Manager\Api\Package\RootPackageFileManager;
use Puli\Manager\Config\AbstractConfigManager;
use ReflectionClass;
use ReflectionException;
use Webmozart\Expression\Expr;
use Webmozart\Expression\Expression;

/**
 * Manages changes to the root package file.
 *
 * Use this class to make persistent changes to the puli.json of a project.
 * Whenever you call methods in this class, the changes will be written to disk.
 *
 * @since  1.0
 *
 * @author Bernhard Schussek <[email protected]>
 */
class RootPackageFileManagerImpl extends AbstractConfigManager implements RootPackageFileManager
{
    /**
     * @var ProjectContext
     */
    private $context;

    /**
     * @var RootPackageFile
     */
    private $rootPackageFile;

    /**
     * @var PackageFileStorage
     */
    private $packageFileStorage;

    /**
     * Creates a new package file manager.
     *
     * @param ProjectContext     $context            The project context
     * @param PackageFileStorage $packageFileStorage The package file storage.
     */
    public function __construct(ProjectContext $context, PackageFileStorage $packageFileStorage)
    {
        $this->context = $context;
        $this->rootPackageFile = $context->getRootPackageFile();
        $this->packageFileStorage = $packageFileStorage;
    }

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

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

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

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

    /**
     * {@inheritdoc}
     */
    public function setPackageName($packageName)

    {
        if ($packageName === $this->rootPackageFile->getPackageName()) {
            return;
        }

        $previousName = $this->rootPackageFile->getPackageName();

        $this->rootPackageFile->setPackageName($packageName);

        try {
            $this->packageFileStorage->saveRootPackageFile($this->rootPackageFile);
        } catch (Exception $e) {
            $this->rootPackageFile->setPackageName($previousName);

            throw $e;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function addPluginClass($pluginClass)

    {
        if ($this->rootPackageFile->hasPluginClass($pluginClass)) {
            // Already installed locally
            return;
        }

        $this->validatePluginClass($pluginClass);

        $previousClasses = $this->rootPackageFile->getPluginClasses();

        $this->rootPackageFile->addPluginClass($pluginClass);

        try {
            $this->packageFileStorage->saveRootPackageFile($this->rootPackageFile);
        } catch (Exception $e) {
            $this->rootPackageFile->setPluginClasses($previousClasses);

            throw $e;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function removePluginClass($pluginClass)
    {
        if (!$this->rootPackageFile->hasPluginClass($pluginClass)) {
            return;
        }

        $previousClasses = $this->rootPackageFile->getPluginClasses();

        $this->rootPackageFile->removePluginClass($pluginClass);

        try {
            $this->packageFileStorage->saveRootPackageFile($this->rootPackageFile);
        } catch (Exception $e) {
            $this->rootPackageFile->setPluginClasses($previousClasses);

            throw $e;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function removePluginClasses(Expression $expr)

    {
        $save = false;
        $previousClasses = $this->rootPackageFile->getPluginClasses();

        foreach ($previousClasses as $pluginClass) {
            if ($expr->evaluate($pluginClass)) {
                $this->rootPackageFile->removePluginClass($pluginClass);
                $save = true;
            }
        }

        if (!$save) {
            return;
        }

        try {
            $this->packageFileStorage->saveRootPackageFile($this->rootPackageFile);
        } catch (Exception $e) {
            $this->rootPackageFile->setPluginClasses($previousClasses);

            throw $e;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function clearPluginClasses()
    {
        $this->removePluginClasses(Expr::true());
    }

    /**
     * {@inheritdoc}
     */
    public function hasPluginClass($pluginClass)
    {
        return $this->rootPackageFile->hasPluginClass($pluginClass);
    }

    /**
     * {@inheritdoc}
     */
    public function hasPluginClasses(Expression $expr = null)

    {
        if (!$expr) {
            return $this->rootPackageFile->hasPluginClasses();
        }

        foreach ($this->rootPackageFile->getPluginClasses() as $pluginClass) {
            if ($expr->evaluate($pluginClass)) {
                return true;
            }
        }

        return false;
    }

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

    /**
     * {@inheritdoc}
     */
    public function findPluginClasses(Expression $expr)
    {
        $pluginClasses = array();

        foreach ($this->rootPackageFile->getPluginClasses() as $pluginClass) {
            if ($expr->evaluate($pluginClass)) {
                $pluginClasses[] = $pluginClass;
            }
        }

        return $pluginClasses;
    }

    /**
     * {@inheritdoc}
     */
    public function setExtraKey($key, $value)
    {
        $previouslySet = $this->rootPackageFile->hasExtraKey($key);
        $previousValue = $this->rootPackageFile->getExtraKey($key);

        if ($value === $previousValue) {
            return;
        }

        $this->rootPackageFile->setExtraKey($key, $value);

        try {
            $this->packageFileStorage->saveRootPackageFile($this->rootPackageFile);
        } catch (Exception $e) {
            if ($previouslySet) {
                $this->rootPackageFile->setExtraKey($key, $previousValue);
            } else {
                $this->rootPackageFile->removeExtraKey($key);
            }

            throw $e;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function setExtraKeys(array $values)
    {
        $previousValues = array();
        $previouslyUnset = array();

        foreach ($values as $key => $value) {
            if ($this->rootPackageFile->hasExtraKey($key)) {
                if ($value !== $previous = $this->rootPackageFile->getExtraKey($key)) {
                    $previousValues[$key] = $previous;
                }
            } else {
                $previouslyUnset[$key] = true;
            }
        }

        if (!$previousValues && !$previouslyUnset) {

            return;
        }

        $this->rootPackageFile->setExtraKeys($values);

        try {
            $this->packageFileStorage->saveRootPackageFile($this->rootPackageFile);
        } catch (Exception $e) {
            foreach ($values as $key => $value) {
                if (isset($previouslyUnset[$key])) {
                    $this->rootPackageFile->removeExtraKey($key);
                } else {
                    $this->rootPackageFile->setExtraKey($key, $previousValues[$key]);
                }
            }

            throw $e;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function removeExtraKey($key)

    {
        if (!$this->rootPackageFile->hasExtraKey($key)) {
            return;
        }

        $previousValue = $this->rootPackageFile->getExtraKey($key);

        $this->rootPackageFile->removeExtraKey($key);

        try {
            $this->packageFileStorage->saveRootPackageFile($this->rootPackageFile);
        } catch (Exception $e) {
            $this->rootPackageFile->setExtraKey($key, $previousValue);

            throw $e;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function removeExtraKeys(Expression $expr)

    {
        $previousValues = $this->rootPackageFile->getExtraKeys();
        $save = false;

        foreach ($this->rootPackageFile->getExtraKeys() as $key => $value) {
            if ($expr->evaluate($key)) {
                $this->rootPackageFile->removeExtraKey($key);
                $save = true;
            }
        }

        if (!$save) {
            return;
        }

        try {
            $this->packageFileStorage->saveRootPackageFile($this->rootPackageFile);
        } catch (Exception $e) {
            $this->rootPackageFile->setExtraKeys($previousValues);

            throw $e;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function clearExtraKeys()

    {
        $previousValues = $this->rootPackageFile->getExtraKeys();

        if (!$previousValues) {

            return;
        }

        $this->rootPackageFile->clearExtraKeys();

        try {
            $this->packageFileStorage->saveRootPackageFile($this->rootPackageFile);
        } catch (Exception $e) {
            $this->rootPackageFile->setExtraKeys($previousValues);

            throw $e;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function hasExtraKey($key)
    {
        return $this->rootPackageFile->hasExtraKey($key);
    }

    /**
     * {@inheritdoc}
     */
    public function hasExtraKeys(Expression $expr = null)

    {
        if (!$expr) {
            return $this->rootPackageFile->hasExtraKeys();
        }

        foreach ($this->rootPackageFile->getExtraKeys() as $key => $value) {
            if ($expr->evaluate($key)) {
                return true;
            }
        }

        return false;
    }

    /**
     * {@inheritdoc}
     */
    public function getExtraKey($key, $default = null)
    {
        return $this->rootPackageFile->getExtraKey($key, $default);
    }

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

    /**
     * {@inheritdoc}
     */
    public function findExtraKeys(Expression $expr)
    {
        $values = array();

        foreach ($this->rootPackageFile->getExtraKeys() as $key => $value) {
            if ($expr->evaluate($key)) {
                $values[$key] = $value;
            }
        }

        return $values;
    }

    /**
     * {@inheritdoc}
     */
    public function migrate($targetVersion)

    {
        $previousVersion = $this->rootPackageFile->getVersion();

        if ($previousVersion === $targetVersion) {
            return;
        }

        $this->rootPackageFile->setVersion($targetVersion);

        try {
            $this->packageFileStorage->saveRootPackageFile($this->rootPackageFile);
        } catch (Exception $e) {
            $this->rootPackageFile->setVersion($previousVersion);

            throw $e;
        }
    }

    /**
     * {@inheritdoc}
     */
    protected function saveConfigFile()
    {
        $this->packageFileStorage->saveRootPackageFile($this->rootPackageFile);
    }

    private function validatePluginClass($pluginClass)
    {
        try {
            $reflClass = new ReflectionClass($pluginClass);
        } catch (ReflectionException $e) {
            throw new InvalidArgumentException(sprintf(
                'The plugin class %s does not exist.',
                $pluginClass
            ), 0, $e);
        }

        if ($reflClass->isInterface()) {
            throw new InvalidArgumentException(sprintf(
                'The plugin class %s should be a class, but is an interface.',
                $pluginClass
            ));
        }

        if (version_compare(PHP_VERSION, '5.4.0', '>=') && $reflClass->isTrait()) {
            throw new InvalidArgumentException(sprintf(
                'The plugin class %s should be a class, but is a trait.',
                $pluginClass
            ));
        }

        if (!$reflClass->implementsInterface('\Puli\Manager\Api\PuliPlugin')) {
            throw new InvalidArgumentException(sprintf(
                'The plugin class %s must implement PuliPlugin.',
                $pluginClass
            ));
        }

        $constructor = $reflClass->getConstructor();

        if (null !== $constructor && $constructor->getNumberOfRequiredParameters() > 0) {
            throw new InvalidArgumentException(sprintf(
                'The constructor of the plugin class %s must not have required '.
                'parameters.',
                $pluginClass
            ));
        }
    }
}


1			<?php
2
3			/*
4			* This file is part of the puli/manager package.
5			*
6			* (c) Bernhard Schussek <[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 Puli\Manager\Package;
13
14			use Exception;
15			use InvalidArgumentException;
16			use Puli\Manager\Api\Context\ProjectContext;
17			use Puli\Manager\Api\Package\RootPackageFile;
18			use Puli\Manager\Api\Package\RootPackageFileManager;
19			use Puli\Manager\Config\AbstractConfigManager;
20			use ReflectionClass;
21			use ReflectionException;
22			use Webmozart\Expression\Expr;
23			use Webmozart\Expression\Expression;
24
25			/**
26			* Manages changes to the root package file.
27			*
28			* Use this class to make persistent changes to the puli.json of a project.
29			* Whenever you call methods in this class, the changes will be written to disk.
30			*
31			* @since 1.0
32			*
33			* @author Bernhard Schussek <[email protected]>
34			*/
35			class RootPackageFileManagerImpl extends AbstractConfigManager implements RootPackageFileManager
36			{
37			/**
38			* @var ProjectContext
39			*/
40			private $context;
41
42			/**
43			* @var RootPackageFile
44			*/
45			private $rootPackageFile;
46
47			/**
48			* @var PackageFileStorage
49			*/
50			private $packageFileStorage;
51
52			/**
53			* Creates a new package file manager.
54			*
55			* @param ProjectContext $context The project context
56			* @param PackageFileStorage $packageFileStorage The package file storage.
57			*/
58	79		public function __construct(ProjectContext $context, PackageFileStorage $packageFileStorage)
59			{
60	79		$this->context = $context;
61	79		$this->rootPackageFile = $context->getRootPackageFile();
62	79		$this->packageFileStorage = $packageFileStorage;
63	79		}
64
65			/**
66			* {@inheritdoc}
67			*/
68	17		public function getConfig()
69			{
70	17		return $this->rootPackageFile->getConfig();
71			}
72
73			/**
74			* {@inheritdoc}
75			*/
76	1		public function getContext()
77			{
78	1		return $this->context;
79			}
80
81			/**
82			* {@inheritdoc}
83			*/
84			public function getPackageFile()
85			{
86			return $this->rootPackageFile;
87			}
88
89			/**
90			* {@inheritdoc}
91			*/
92	4		public function getPackageName()
93			{
94	4		return $this->rootPackageFile->getPackageName();
95			}
96
97			/**
98			* {@inheritdoc}
99			*/
100	3	View Code Duplication	public function setPackageName($packageName)
			0 ignored issues – show Duplication introduced 2015-12-06 22:18 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
101			{
102	3		if ($packageName === $this->rootPackageFile->getPackageName()) {
103	1		return;
104			}
105
106	2		$previousName = $this->rootPackageFile->getPackageName();
107
108	2		$this->rootPackageFile->setPackageName($packageName);
109
110			try {
111	2		$this->packageFileStorage->saveRootPackageFile($this->rootPackageFile);
112	2		} catch (Exception $e) {
113	1		$this->rootPackageFile->setPackageName($previousName);
114
115	1		throw $e;
116			}
117	1		}
118
119			/**
120			* {@inheritdoc}
121			*/
122	7	View Code Duplication	public function addPluginClass($pluginClass)
			0 ignored issues – show Duplication introduced 2015-12-06 22:18 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
123			{
124	7		if ($this->rootPackageFile->hasPluginClass($pluginClass)) {
125			// Already installed locally
126	1		return;
127			}
128
129	6		$this->validatePluginClass($pluginClass);
130
131	2		$previousClasses = $this->rootPackageFile->getPluginClasses();
132
133	2		$this->rootPackageFile->addPluginClass($pluginClass);
134
135			try {
136	2		$this->packageFileStorage->saveRootPackageFile($this->rootPackageFile);
137	2		} catch (Exception $e) {
138	1		$this->rootPackageFile->setPluginClasses($previousClasses);
139
140	1		throw $e;
141			}
142	1		}
143
144			/**
145			* {@inheritdoc}
146			*/
147	3		public function removePluginClass($pluginClass)
148			{
149	3		if (!$this->rootPackageFile->hasPluginClass($pluginClass)) {
150	1		return;
151			}
152
153	2		$previousClasses = $this->rootPackageFile->getPluginClasses();
154
155	2		$this->rootPackageFile->removePluginClass($pluginClass);
156
157			try {
158	2		$this->packageFileStorage->saveRootPackageFile($this->rootPackageFile);
159	2		} catch (Exception $e) {
160	1		$this->rootPackageFile->setPluginClasses($previousClasses);
161
162	1		throw $e;
163			}
164	1		}
165
166			/**
167			* {@inheritdoc}
168			*/
169	7	View Code Duplication	public function removePluginClasses(Expression $expr)
			0 ignored issues – show Duplication introduced 2015-12-06 22:18 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
170			{
171	7		$save = false;
172	7		$previousClasses = $this->rootPackageFile->getPluginClasses();
173
174	7		foreach ($previousClasses as $pluginClass) {
175	6		if ($expr->evaluate($pluginClass)) {
176	5		$this->rootPackageFile->removePluginClass($pluginClass);
177	5		$save = true;
178	5		}
179	7		}
180
181	7		if (!$save) {
182	2		return;
183			}
184
185			try {
186	5		$this->packageFileStorage->saveRootPackageFile($this->rootPackageFile);
187	5		} catch (Exception $e) {
188	2		$this->rootPackageFile->setPluginClasses($previousClasses);
189
190	2		throw $e;
191			}
192	3		}
193
194			/**
195			* {@inheritdoc}
196			*/
197	3		public function clearPluginClasses()
198			{
199	3		$this->removePluginClasses(Expr::true());
200	2		}
201
202			/**
203			* {@inheritdoc}
204			*/
205	1		public function hasPluginClass($pluginClass)
206			{
207	1		return $this->rootPackageFile->hasPluginClass($pluginClass);
208			}
209
210			/**
211			* {@inheritdoc}
212			*/
213	1	View Code Duplication	public function hasPluginClasses(Expression $expr = null)
			0 ignored issues – show Duplication introduced 2015-12-06 22:18 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
214			{
215	1		if (!$expr) {
216	1		return $this->rootPackageFile->hasPluginClasses();
217			}
218
219	1		foreach ($this->rootPackageFile->getPluginClasses() as $pluginClass) {
220	1		if ($expr->evaluate($pluginClass)) {
221	1		return true;
222			}
223	1		}
224
225	1		return false;
226			}
227
228			/**
229			* {@inheritdoc}
230			*/
231	14		public function getPluginClasses()
232			{
233	14		return $this->rootPackageFile->getPluginClasses();
234			}
235
236			/**
237			* {@inheritdoc}
238			*/
239	1		public function findPluginClasses(Expression $expr)
240			{
241	1		$pluginClasses = array();
242
243	1		foreach ($this->rootPackageFile->getPluginClasses() as $pluginClass) {
244	1		if ($expr->evaluate($pluginClass)) {
245	1		$pluginClasses[] = $pluginClass;
246	1		}
247	1		}
248
249	1		return $pluginClasses;
250			}
251
252			/**
253			* {@inheritdoc}
254			*/
255	4		public function setExtraKey($key, $value)
256			{
257	4		$previouslySet = $this->rootPackageFile->hasExtraKey($key);
258	4		$previousValue = $this->rootPackageFile->getExtraKey($key);
259
260	4		if ($value === $previousValue) {
261	1		return;
262			}
263
264	3		$this->rootPackageFile->setExtraKey($key, $value);
265
266			try {
267	3		$this->packageFileStorage->saveRootPackageFile($this->rootPackageFile);
268	3		} catch (Exception $e) {
269	2		if ($previouslySet) {
270	1		$this->rootPackageFile->setExtraKey($key, $previousValue);
271	1		} else {
272	1		$this->rootPackageFile->removeExtraKey($key);
273			}
274
275	2		throw $e;
276			}
277	1		}
278
279			/**
280			* {@inheritdoc}
281			*/
282	3		public function setExtraKeys(array $values)
283			{
284	3		$previousValues = array();
285	3		$previouslyUnset = array();
286
287	3		foreach ($values as $key => $value) {
288	3		if ($this->rootPackageFile->hasExtraKey($key)) {
289	2		if ($value !== $previous = $this->rootPackageFile->getExtraKey($key)) {
290	1		$previousValues[$key] = $previous;
291	1		}
292	2		} else {
293	2		$previouslyUnset[$key] = true;
294			}
295	3		}
296
297	3		if (!$previousValues && !$previouslyUnset) {
			0 ignored issues – show Bug Best Practice introduced 2015-12-06 22:18 UTC by Report Bug Copy Issue Report The expression `$previousValues` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history... Bug Best Practice introduced 2015-12-06 22:18 UTC by Report Bug Copy Issue Report The expression `$previouslyUnset` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
298	1		return;
299			}
300
301	2		$this->rootPackageFile->setExtraKeys($values);
302
303			try {
304	2		$this->packageFileStorage->saveRootPackageFile($this->rootPackageFile);
305	2		} catch (Exception $e) {
306	1		foreach ($values as $key => $value) {
307	1		if (isset($previouslyUnset[$key])) {
308	1		$this->rootPackageFile->removeExtraKey($key);
309	1		} else {
310	1		$this->rootPackageFile->setExtraKey($key, $previousValues[$key]);
311			}
312	1		}
313
314	1		throw $e;
315			}
316	1		}
317
318			/**
319			* {@inheritdoc}
320			*/
321	3	View Code Duplication	public function removeExtraKey($key)
			0 ignored issues – show Duplication introduced 2015-12-06 22:18 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
322			{
323	3		if (!$this->rootPackageFile->hasExtraKey($key)) {
324	1		return;
325			}
326
327	2		$previousValue = $this->rootPackageFile->getExtraKey($key);
328
329	2		$this->rootPackageFile->removeExtraKey($key);
330
331			try {
332	2		$this->packageFileStorage->saveRootPackageFile($this->rootPackageFile);
333	2		} catch (Exception $e) {
334	1		$this->rootPackageFile->setExtraKey($key, $previousValue);
335
336	1		throw $e;
337			}
338	1		}
339
340			/**
341			* {@inheritdoc}
342			*/
343	3	View Code Duplication	public function removeExtraKeys(Expression $expr)
			0 ignored issues – show Duplication introduced 2015-12-06 22:18 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
344			{
345	3		$previousValues = $this->rootPackageFile->getExtraKeys();
346	3		$save = false;
347
348	3		foreach ($this->rootPackageFile->getExtraKeys() as $key => $value) {
349	2		if ($expr->evaluate($key)) {
350	2		$this->rootPackageFile->removeExtraKey($key);
351	2		$save = true;
352	2		}
353	3		}
354
355	3		if (!$save) {
356	1		return;
357			}
358
359			try {
360	2		$this->packageFileStorage->saveRootPackageFile($this->rootPackageFile);
361	2		} catch (Exception $e) {
362	1		$this->rootPackageFile->setExtraKeys($previousValues);
363
364	1		throw $e;
365			}
366	1		}
367
368			/**
369			* {@inheritdoc}
370			*/
371	3	View Code Duplication	public function clearExtraKeys()
			0 ignored issues – show Duplication introduced 2015-12-06 22:18 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
372			{
373	3		$previousValues = $this->rootPackageFile->getExtraKeys();
374
375	3		if (!$previousValues) {
			0 ignored issues – show Bug Best Practice introduced 2015-12-06 22:18 UTC by Report Bug Copy Issue Report The expression `$previousValues` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
376	1		return;
377			}
378
379	2		$this->rootPackageFile->clearExtraKeys();
380
381			try {
382	2		$this->packageFileStorage->saveRootPackageFile($this->rootPackageFile);
383	2		} catch (Exception $e) {
384	1		$this->rootPackageFile->setExtraKeys($previousValues);
385
386	1		throw $e;
387			}
388	1		}
389
390			/**
391			* {@inheritdoc}
392			*/
393	1		public function hasExtraKey($key)
394			{
395	1		return $this->rootPackageFile->hasExtraKey($key);
396			}
397
398			/**
399			* {@inheritdoc}
400			*/
401	1	View Code Duplication	public function hasExtraKeys(Expression $expr = null)
			0 ignored issues – show Duplication introduced 2015-12-06 22:18 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
402			{
403	1		if (!$expr) {
404	1		return $this->rootPackageFile->hasExtraKeys();
405			}
406
407	1		foreach ($this->rootPackageFile->getExtraKeys() as $key => $value) {
408	1		if ($expr->evaluate($key)) {
409	1		return true;
410			}
411	1		}
412
413	1		return false;
414			}
415
416			/**
417			* {@inheritdoc}
418			*/
419	15		public function getExtraKey($key, $default = null)
420			{
421	15		return $this->rootPackageFile->getExtraKey($key, $default);
422			}
423
424			/**
425			* {@inheritdoc}
426			*/
427	1		public function getExtraKeys()
428			{
429	1		return $this->rootPackageFile->getExtraKeys();
430			}
431
432			/**
433			* {@inheritdoc}
434			*/
435	1		public function findExtraKeys(Expression $expr)
436			{
437	1		$values = array();
438
439	1		foreach ($this->rootPackageFile->getExtraKeys() as $key => $value) {
440	1		if ($expr->evaluate($key)) {
441	1		$values[$key] = $value;
442	1		}
443	1		}
444
445	1		return $values;
446			}
447
448			/**
449			* {@inheritdoc}
450			*/
451	2	View Code Duplication	public function migrate($targetVersion)
			0 ignored issues – show Duplication introduced 2015-12-06 22:18 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
452			{
453	2		$previousVersion = $this->rootPackageFile->getVersion();
454
455	2		if ($previousVersion === $targetVersion) {
456			return;
457			}
458
459	2		$this->rootPackageFile->setVersion($targetVersion);
460
461			try {
462	2		$this->packageFileStorage->saveRootPackageFile($this->rootPackageFile);
463	2		} catch (Exception $e) {
464	1		$this->rootPackageFile->setVersion($previousVersion);
465
466	1		throw $e;
467			}
468	1		}
469
470			/**
471			* {@inheritdoc}
472			*/
473	4		protected function saveConfigFile()
474			{
475	4		$this->packageFileStorage->saveRootPackageFile($this->rootPackageFile);
476	4		}
477
478	6		private function validatePluginClass($pluginClass)
479			{
480			try {
481	6		$reflClass = new ReflectionClass($pluginClass);
482	6		} catch (ReflectionException $e) {
483	1		throw new InvalidArgumentException(sprintf(
484	1		'The plugin class %s does not exist.',
485			$pluginClass
486	1		), 0, $e);
487			}
488
489	5		if ($reflClass->isInterface()) {
490	1		throw new InvalidArgumentException(sprintf(
491	1		'The plugin class %s should be a class, but is an interface.',
492			$pluginClass
493	1		));
494			}
495
496	4		if (version_compare(PHP_VERSION, '5.4.0', '>=') && $reflClass->isTrait()) {
497			throw new InvalidArgumentException(sprintf(
498			'The plugin class %s should be a class, but is a trait.',
499			$pluginClass
500			));
501			}
502
503	4		if (!$reflClass->implementsInterface('\Puli\Manager\Api\PuliPlugin')) {
504	1		throw new InvalidArgumentException(sprintf(
505	1		'The plugin class %s must implement PuliPlugin.',
506			$pluginClass
507	1		));
508			}
509
510	3		$constructor = $reflClass->getConstructor();
511
512	3		if (null !== $constructor && $constructor->getNumberOfRequiredParameters() > 0) {
513	1		throw new InvalidArgumentException(sprintf(
514			'The constructor of the plugin class %s must not have required '.
515	1		'parameters.',
516			$pluginClass
517	1		));
518			}
519	2		}
520			}
521

puli / manager