Composer - Code Metrics - Inspection of "fix" - SamsonPHP/composer - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 02ecea...59b1a5 )

by Nikita

created 2015-12-17 13:00 UTC

Composer C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	354
Duplicated Lines	2.82 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes	7
Bugs	4	Features	4

Metric	Value
wmc	58
c	7
b	4
f	4
lcom	1
cbo	0
dl	10
loc	354
rs	6.3006

17 Methods

Rating	Name	Duplication	Size	Complexity
A	vendor()	0	7	2
A	ignoreKey()	0	5	1
A	includeKey()	0	5	1
A	ignorePackage()	0	7	2
B	create()	0	24	4
C	sort()	0	25	7
B	checkSort()	0	20	5
A	includeList()	0	12	4
A	isInclude()	0	12	4
A	isIgnore()	0	11	4
B	packagesFill()	0	17	5
A	readFile()	0	17	4
C	getRequiredList()	5	22	7
A	getReqList()	5	13	4
A	clear()	0	8	1
A	insertKeyAfter()	0	7	2
A	insertKeyBefore()	0	6	1

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 Composer 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 Composer, and based on these observations, apply Extract Interface, too.

<?php
/**
 * Created by PhpStorm.
 * User: Nikita Kotenko
 * Date: 26.11.2014
 * Time: 14:12
 */
namespace samsonphp\composer;


/**
 * Provide creating sorting list of composer packages
 * @package samson
 */
class Composer
{
    /** @var string Path to current web-application */
    private $systemPath;

    /** @var string  composer lock file name */
    private $lockFileName = 'composer.lock';

    /** @var array List of available vendors */
    private $vendorsList = array();

    /** @var string $ignoreKey */
    private $ignoreKey;

    /** @var string $includeKey */
    private $includeKey;

    /** @var array List of ignored packages */
    private $ignorePackages = array();

    /** @var array  Packages list with require packages*/
    private $packagesList = array();

	private $packagesListExtra = array();

    /**
     *  Add available vendor
     * @param $vendor Available vendor
     * @return $this
     */
    public function vendor($vendor)
    {
        if (!in_array($vendor, $this->vendorsList)) {
            $this->vendorsList[] = $vendor.'/';
        }
        return $this;
    }


    /**
     * Set name of composer extra parameter to ignore package
     * @param $ignoreKey Name
     * @return $this
     */
    public function ignoreKey($ignoreKey)
    {
        $this->ignoreKey = $ignoreKey;
        return $this;
    }

    /**
     * Set name of composer extra parameter to include package
     * @param $includeKey Name
     * @return $this
     */
    public function includeKey($includeKey)
    {
        $this->includeKey = $includeKey;
        return $this;
    }

    /**
     *  Add ignored package
     * @param $vendor Ignored package
     * @return $this
     */
    public function ignorePackage($package)
    {
        if (!in_array($package, $this->ignorePackages)) {
            $this->ignorePackages[] = $package;
        }
        return $this;
    }

    /**
     * Create sorted packages list
     * @return array Packages list ('package name'=>'rating')
     */
    public function create(& $packages, $systemPath, $parameters = array())
    {
	    $class_vars = get_class_vars(get_class($this));

	    foreach ($class_vars as $name => $value) {
		    if (isset($parameters[$name])) {
			    $this->$name = $parameters[$name];
		    }
	    }
        // Composer.lock is always in the project root folder
        $path = $systemPath.$this->lockFileName;

        // Create list of relevant packages with there require packages
        $this->packagesFill($this->readFile($path));

        $resultList = $this->sort();

	    foreach ($resultList as $package => $rating) {
            $required = $this->getRequiredList($package);
		    $packages[$package] = $this->packagesListExtra[$package];
            $packages[$package]['required'] = $required;
            $packages[$package]['composerName'] =$package;
	    }
    }

    /**
     * Provide creating sorting list
     * @return array list of sorted packages
     */
    public function sort()
    {
        $list = array();
        foreach ($this->packagesList as $package => $requiredList) {
            if (!sizeof($list)||!isset($list[$package])) {
                $list[$package] = 1;
            }
            foreach ($requiredList as $requiredPackage) {
                if (isset($list[$requiredPackage])) {
                    $packagePos =  array_search($package, array_keys($list));
                    $requiredPackagePos = array_search($requiredPackage, array_keys($list));
                    if ($packagePos < $requiredPackagePos) {
                        unset($list[$requiredPackage]);
                        $list = $this->insertKeyBefore($list, $package, $requiredPackage);
                    }
                } else {
                    $list = $this->insertKeyBefore($list, $package, $requiredPackage);
                }

            }
        }
        //$this->checkSort($list);

        return $list;
    }

    /**
     *Check result of sorting
     * @param $list final list of packages
     *
     * @return bool result
     */
    public function checkSort($list)
    {
        $status = true;
        foreach ($this->packagesList as $package => $requiredList) {
            foreach ($requiredList as $requiredPackage) {
                if (isset($list[$requiredPackage])) {
                    $packagePos =  array_search($package, array_keys($list));
                    $requiredPackagePos = array_search($requiredPackage, array_keys($list));
                    if ($packagePos < $requiredPackagePos) {
                        trace('error pos - '.$packagePos.' < '.$requiredPackagePos);
                        $status = false;
                    }
                } else {
                    $status = false;
                    trace('error not isset!!!!! - '.$requiredPackage);
                }
            }
        }
        return $status;
    }



    /**
     * Create list of relevant packages
     * @param $packages Composer lock list of packages
     * @return array List of relevant packages
     */
    private function includeList($packages)
    {
        $includePackages = array();
        foreach ($packages as $package) {
            if (!$this->isIgnore($package)) {
                if ($this->isInclude($package)) {
                    $includePackages[] = $package['name'];
                }
            }
        }
        return $includePackages;
    }

    /**
     * Is package include
     * @param $package Composer package
     * @return bool - is package include
     */
    private function isInclude($package)
    {
        $include = true;
        if (sizeof($this->vendorsList)) {
            if (!isset($this->includeKey) || !isset($package['extra'][$this->includeKey])) {
                $packageName = $package['name'];
			    $vendorName = substr($packageName, 0, strpos($packageName,"/")+1);
                $include = in_array($vendorName, $this->vendorsList);
            }
        }
        return $include;
    }

    /**
     * Is package ignored
     * @param $package Composer package
     * @return bool - is package ignored
     */
    private function isIgnore($package)
    {
        $isIgnore = false;
        if (in_array($package['name'], $this->ignorePackages)) {
            $isIgnore = true;
        }
        if (isset($this->ignoreKey)&&(isset($package['extra'][$this->ignoreKey]))) {
            $isIgnore = true;
        }
        return $isIgnore;
    }

    /**
     * Fill list of relevant packages with there require packages
     * @param $packages Composer lock file object
     */
    private function packagesFill($packages)
    {
        // Get included packages list
        $includePackages = $this->includeList($packages);

        // Create list of relevant packages with there require packages
        foreach ($packages as $package) {
            $requirement = $package['name'];
            if (in_array($requirement, $includePackages)) {
                $this->packagesList[$requirement] = array();
	            $this->packagesListExtra[$requirement] = isset($package['extra'])?$package['extra']:array();
                if (isset($package['require'])) {
                    $this->packagesList[$requirement] = array_intersect(array_keys($package['require']), $includePackages);
                }
            }
        }
    }

    private function readFile($path)
    {
        $packages = array();
        // If we have composer configuration file
        if (file_exists($path)) {
            // Read file into object
            $composerObject = json_decode(file_get_contents($path), true);

            // Gather all possible packages
            $packages = array_merge(
                array(),
                isset($composerObject['packages']) ? $composerObject['packages'] : array(),
                isset($composerObject['packages-dev']) ? $composerObject['packages-dev'] : array()
            );
        }
        return $packages;
    }

    /**
     * Create list of of required packages
     * @param null $includeModule Dependent package
     * @param array $ignoreModules
     *
     * @return array required packages
     */
    private function getRequiredList($includeModule = null, $ignoreModules = array())
    {
        $list = isset($includeModule)?$this->packagesList[$includeModule]:$this->packagesList;
        $ignoreList = array();
        foreach ($ignoreModules as $module) {
            $ignoreList[] = $module;
            if (is_array($this->packagesList[$module])) {
                $ignoreList = array_merge($ignoreList, $this->packagesList[$module]);
            }
        }

        $result = array();
        foreach ($list as $k=>$v) {

            $module = is_array($v)?$k:$v;
            if (!in_array($module, $ignoreList)) {

                $result[] = $module;
                $moduleList = $this->getReqList($this->packagesList[$module]);
                $result = array_merge($result, $moduleList);
            }
        }
        return array_values(array_unique($result));
    }

    /**
     * Recursive function that get list of required packages
     * @param $list List of packages
     * @param array $result
     *
     * @return array required packages
     */
    private function getReqList($list, $result = array()) {
        $return = array();
        if (is_array($list)) {
            foreach ($list as $module) {
                if (!in_array($module, $result)) {

                    $getList = $this->getReqList($this->packagesList[$module], $return);
                    $return[] = $module;
                    $return = array_merge($return, $getList);
                }
            }
        }
        return $return;
    }

	/**
	 * Clear object parameters
	 */
	public function clear()
	{
		$this->vendorsList = array();
		$this->ignoreKey = null;
		$this->includeKey = null;
		$this->ignorePackages = array();
		$this->packagesList = array();
	}

    /**
     * Insert a key after a specific key in an array.  If key doesn't exist, value is appended
     * to the end of the array.
     *
     * @param array $array
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * @param string $key
     * @param integer $newKey
     *
     * @return array
     */
    public function insertKeyAfter( array $list, $key, $newKey )

    {
        $keys = array_keys($list);
        $index = array_search( $key, $keys );
        $pos = false === $index ? count($list) : $index + 1;
        return array_merge(array_slice($list, 0, $pos), array($newKey=>1), array_slice($list, $pos));
    }

    /**
     * Insert a key before a specific key in an array.  If key doesn't exist, value is prepended
     * to the beginning of the array.
     *
     * @param array $array
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * @param string $key
     * @param integer $newKey
     *
     * @return array
     */
    public function insertKeyBefore(array $list, $key, $newKey)
    {
        $keys = array_keys($list);
        $pos = (int) array_search($key, $keys);
        return array_merge(array_slice($list, 0, $pos), array($newKey=>1), array_slice($list, $pos));
    }

}


1		<?php
2		/**
3		* Created by PhpStorm.
4		* User: Nikita Kotenko
5		* Date: 26.11.2014
6		* Time: 14:12
7		*/
8		namespace samsonphp\composer;
9
10
11		/**
12		* Provide creating sorting list of composer packages
13		* @package samson
14		*/
15		class Composer
16		{
17		/** @var string Path to current web-application */
18		private $systemPath;
19
20		/** @var string composer lock file name */
21		private $lockFileName = 'composer.lock';
22
23		/** @var array List of available vendors */
24		private $vendorsList = array();
25
26		/** @var string $ignoreKey */
27		private $ignoreKey;
28
29		/** @var string $includeKey */
30		private $includeKey;
31
32		/** @var array List of ignored packages */
33		private $ignorePackages = array();
34
35		/** @var array Packages list with require packages*/
36		private $packagesList = array();
37
38		private $packagesListExtra = array();
39
40		/**
41		* Add available vendor
42		* @param $vendor Available vendor
43		* @return $this
44		*/
45		public function vendor($vendor)
46		{
47		if (!in_array($vendor, $this->vendorsList)) {
48		$this->vendorsList[] = $vendor.'/';
49		}
50		return $this;
51		}
52
53
54		/**
55		* Set name of composer extra parameter to ignore package
56		* @param $ignoreKey Name
57		* @return $this
58		*/
59		public function ignoreKey($ignoreKey)
60		{
61		$this->ignoreKey = $ignoreKey;
62		return $this;
63		}
64
65		/**
66		* Set name of composer extra parameter to include package
67		* @param $includeKey Name
68		* @return $this
69		*/
70		public function includeKey($includeKey)
71		{
72		$this->includeKey = $includeKey;
73		return $this;
74		}
75
76		/**
77		* Add ignored package
78		* @param $vendor Ignored package
79		* @return $this
80		*/
81		public function ignorePackage($package)
82		{
83		if (!in_array($package, $this->ignorePackages)) {
84		$this->ignorePackages[] = $package;
85		}
86		return $this;
87		}
88
89		/**
90		* Create sorted packages list
91		* @return array Packages list ('package name'=>'rating')
92		*/
93		public function create(& $packages, $systemPath, $parameters = array())
94		{
95		$class_vars = get_class_vars(get_class($this));
96
97		foreach ($class_vars as $name => $value) {
98		if (isset($parameters[$name])) {
99		$this->$name = $parameters[$name];
100		}
101		}
102		// Composer.lock is always in the project root folder
103		$path = $systemPath.$this->lockFileName;
104
105		// Create list of relevant packages with there require packages
106		$this->packagesFill($this->readFile($path));
107
108		$resultList = $this->sort();
109
110		foreach ($resultList as $package => $rating) {
111		$required = $this->getRequiredList($package);
112		$packages[$package] = $this->packagesListExtra[$package];
113		$packages[$package]['required'] = $required;
114		$packages[$package]['composerName'] =$package;
115		}
116		}
117
118		/**
119		* Provide creating sorting list
120		* @return array list of sorted packages
121		*/
122		public function sort()
123		{
124		$list = array();
125		foreach ($this->packagesList as $package => $requiredList) {
126		if (!sizeof($list)\|\|!isset($list[$package])) {
127		$list[$package] = 1;
128		}
129		foreach ($requiredList as $requiredPackage) {
130		if (isset($list[$requiredPackage])) {
131		$packagePos = array_search($package, array_keys($list));
132		$requiredPackagePos = array_search($requiredPackage, array_keys($list));
133		if ($packagePos < $requiredPackagePos) {
134		unset($list[$requiredPackage]);
135		$list = $this->insertKeyBefore($list, $package, $requiredPackage);
136		}
137		} else {
138		$list = $this->insertKeyBefore($list, $package, $requiredPackage);
139		}
140
141		}
142		}
143		//$this->checkSort($list);
144
145		return $list;
146		}
147
148		/**
149		*Check result of sorting
150		* @param $list final list of packages
151		*
152		* @return bool result
153		*/
154		public function checkSort($list)
155		{
156		$status = true;
157		foreach ($this->packagesList as $package => $requiredList) {
158		foreach ($requiredList as $requiredPackage) {
159		if (isset($list[$requiredPackage])) {
160		$packagePos = array_search($package, array_keys($list));
161		$requiredPackagePos = array_search($requiredPackage, array_keys($list));
162		if ($packagePos < $requiredPackagePos) {
163		trace('error pos - '.$packagePos.' < '.$requiredPackagePos);
164		$status = false;
165		}
166		} else {
167		$status = false;
168		trace('error not isset!!!!! - '.$requiredPackage);
169		}
170		}
171		}
172		return $status;
173		}
174
175
176
177		/**
178		* Create list of relevant packages
179		* @param $packages Composer lock list of packages
180		* @return array List of relevant packages
181		*/
182		private function includeList($packages)
183		{
184		$includePackages = array();
185		foreach ($packages as $package) {
186		if (!$this->isIgnore($package)) {
187		if ($this->isInclude($package)) {
188		$includePackages[] = $package['name'];
189		}
190		}
191		}
192		return $includePackages;
193		}
194
195		/**
196		* Is package include
197		* @param $package Composer package
198		* @return bool - is package include
199		*/
200		private function isInclude($package)
201		{
202		$include = true;
203		if (sizeof($this->vendorsList)) {
204		if (!isset($this->includeKey) \|\| !isset($package['extra'][$this->includeKey])) {
205		$packageName = $package['name'];
206		$vendorName = substr($packageName, 0, strpos($packageName,"/")+1);
207		$include = in_array($vendorName, $this->vendorsList);
208		}
209		}
210		return $include;
211		}
212
213		/**
214		* Is package ignored
215		* @param $package Composer package
216		* @return bool - is package ignored
217		*/
218		private function isIgnore($package)
219		{
220		$isIgnore = false;
221		if (in_array($package['name'], $this->ignorePackages)) {
222		$isIgnore = true;
223		}
224		if (isset($this->ignoreKey)&&(isset($package['extra'][$this->ignoreKey]))) {
225		$isIgnore = true;
226		}
227		return $isIgnore;
228		}
229
230		/**
231		* Fill list of relevant packages with there require packages
232		* @param $packages Composer lock file object
233		*/
234		private function packagesFill($packages)
235		{
236		// Get included packages list
237		$includePackages = $this->includeList($packages);
238
239		// Create list of relevant packages with there require packages
240		foreach ($packages as $package) {
241		$requirement = $package['name'];
242		if (in_array($requirement, $includePackages)) {
243		$this->packagesList[$requirement] = array();
244		$this->packagesListExtra[$requirement] = isset($package['extra'])?$package['extra']:array();
245		if (isset($package['require'])) {
246		$this->packagesList[$requirement] = array_intersect(array_keys($package['require']), $includePackages);
247		}
248		}
249		}
250		}
251
252		private function readFile($path)
253		{
254		$packages = array();
255		// If we have composer configuration file
256		if (file_exists($path)) {
257		// Read file into object
258		$composerObject = json_decode(file_get_contents($path), true);
259
260		// Gather all possible packages
261		$packages = array_merge(
262		array(),
263		isset($composerObject['packages']) ? $composerObject['packages'] : array(),
264		isset($composerObject['packages-dev']) ? $composerObject['packages-dev'] : array()
265		);
266		}
267		return $packages;
268		}
269
270		/**
271		* Create list of of required packages
272		* @param null $includeModule Dependent package
273		* @param array $ignoreModules
274		*
275		* @return array required packages
276		*/
277		private function getRequiredList($includeModule = null, $ignoreModules = array())
278		{
279		$list = isset($includeModule)?$this->packagesList[$includeModule]:$this->packagesList;
280		$ignoreList = array();
281		foreach ($ignoreModules as $module) {
282		$ignoreList[] = $module;
283		if (is_array($this->packagesList[$module])) {
284		$ignoreList = array_merge($ignoreList, $this->packagesList[$module]);
285		}
286		}
287
288		$result = array();
289		foreach ($list as $k=>$v) {
		0 ignored issues – show Coding Style introduced 2015-12-11 14:12 UTC by Report Bug Copy Issue Report Expected 1 space before "=>"; 0 found Loading history... Coding Style introduced 2015-12-11 14:12 UTC by Report Bug Copy Issue Report Expected 1 space after "=>"; 0 found Loading history...
290		$module = is_array($v)?$k:$v;
291	View Code Duplication	if (!in_array($module, $ignoreList)) {
		0 ignored issues – show Duplication introduced 2015-12-11 14:12 UTC by Report Bug Copy Issue Report This code seems to be duplicated across 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...
292		$result[] = $module;
293		$moduleList = $this->getReqList($this->packagesList[$module]);
294		$result = array_merge($result, $moduleList);
295		}
296		}
297		return array_values(array_unique($result));
298		}
299
300		/**
301		* Recursive function that get list of required packages
302		* @param $list List of packages
303		* @param array $result
304		*
305		* @return array required packages
306		*/
307		private function getReqList($list, $result = array()) {
308		$return = array();
309		if (is_array($list)) {
310		foreach ($list as $module) {
311	View Code Duplication	if (!in_array($module, $result)) {
		0 ignored issues – show Duplication introduced 2015-12-11 14:12 UTC by Report Bug Copy Issue Report This code seems to be duplicated across 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...
312		$getList = $this->getReqList($this->packagesList[$module], $return);
313		$return[] = $module;
314		$return = array_merge($return, $getList);
315		}
316		}
317		}
318		return $return;
319		}
320
321		/**
322		* Clear object parameters
323		*/
324		public function clear()
325		{
326		$this->vendorsList = array();
327		$this->ignoreKey = null;
328		$this->includeKey = null;
329		$this->ignorePackages = array();
330		$this->packagesList = array();
331		}
332
333		/**
334		* Insert a key after a specific key in an array. If key doesn't exist, value is appended
335		* to the end of the array.
336		*
337		* @param array $array
		0 ignored issues – show Bug introduced 2015-12-17 13:05 UTC by Report Bug Copy Issue Report There is no parameter named `$array`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
338		* @param string $key
339		* @param integer $newKey
340		*
341		* @return array
342		*/
343		public function insertKeyAfter( array $list, $key, $newKey )
		0 ignored issues – show Coding Style introduced 2015-12-17 12:44 UTC by Report Bug Copy Issue Report Expected 0 spaces between opening bracket and type hint "array"; 1 found Loading history... Coding Style introduced 2015-12-17 12:44 UTC by Report Bug Copy Issue Report Expected 0 spaces between argument "$newKey" and closing bracket; 1 found Loading history...
344		{
345		$keys = array_keys($list);
346		$index = array_search( $key, $keys );
347		$pos = false === $index ? count($list) : $index + 1;
348		return array_merge(array_slice($list, 0, $pos), array($newKey=>1), array_slice($list, $pos));
349		}
350
351		/**
352		* Insert a key before a specific key in an array. If key doesn't exist, value is prepended
353		* to the beginning of the array.
354		*
355		* @param array $array
		0 ignored issues – show Bug introduced 2015-12-17 13:05 UTC by Report Bug Copy Issue Report There is no parameter named `$array`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
356		* @param string $key
357		* @param integer $newKey
358		*
359		* @return array
360		*/
361		public function insertKeyBefore(array $list, $key, $newKey)
362		{
363		$keys = array_keys($list);
364		$pos = (int) array_search($key, $keys);
365		return array_merge(array_slice($list, 0, $pos), array($newKey=>1), array_slice($list, $pos));
366		}
367
368		}
369

SamsonPHP / composer