Snapshot - Code Metrics - Inspection of "scrutinizer.yml" - p6naveen/project-1 - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 96df1a...267f86 )

by Naveen

created 2016-02-13 09:40 UTC

Snapshot D

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	405
Duplicated Lines	6.91 %

Coupling/Cohesion

Components	4
Dependencies	1

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
wmc	58
c	1
b	0
f	0
lcom	4
cbo	1
dl	28
loc	405
rs	4.8387

22 Methods

Rating	Name	Duplication	Size	Complexity
F	__construct()	0	45	12
A	blacklist()	0	4	1
A	globalVariables()	0	4	1
A	superGlobalVariables()	0	4	1
A	superGlobalArrays()	0	4	1
A	staticAttributes()	0	4	1
A	iniSettings()	0	4	1
A	includedFiles()	0	4	1
A	constants()	0	4	1
A	functions()	0	4	1
A	interfaces()	0	4	1
A	classes()	0	4	1
A	traits()	0	4	1
A	snapshotConstants()	0	8	2
A	snapshotFunctions()	0	6	1
A	snapshotClasses()	14	14	3
A	snapshotInterfaces()	14	14	3
B	snapshotGlobals()	0	17	7
A	snapshotSuperGlobalArray()	0	10	4
C	snapshotStaticAttributes()	0	28	7
B	setupSuperGlobalArrays()	0	26	2
B	canBeSerialized()	0	20	5

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

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

namespace SebastianBergmann\GlobalState;

use ReflectionClass;
use Serializable;

/**
 * A snapshot of global state.
 */
class Snapshot
{
    /**
     * @var Blacklist
     */
    private $blacklist;

    /**
     * @var array
     */
    private $globalVariables = array();

    /**
     * @var array
     */
    private $superGlobalArrays = array();

    /**
     * @var array
     */
    private $superGlobalVariables = array();

    /**
     * @var array
     */
    private $staticAttributes = array();

    /**
     * @var array
     */
    private $iniSettings = array();

    /**
     * @var array
     */
    private $includedFiles = array();

    /**
     * @var array
     */
    private $constants = array();

    /**
     * @var array
     */
    private $functions = array();

    /**
     * @var array
     */
    private $interfaces = array();

    /**
     * @var array
     */
    private $classes = array();

    /**
     * @var array
     */
    private $traits = array();

    /**
     * Creates a snapshot of the current global state.
     *
     * @param Blacklist $blacklist
     * @param bool      $includeGlobalVariables
     * @param bool      $includeStaticAttributes
     * @param bool      $includeConstants
     * @param bool      $includeFunctions
     * @param bool      $includeClasses
     * @param bool      $includeInterfaces
     * @param bool      $includeTraits
     * @param bool      $includeIniSettings
     * @param bool      $includeIncludedFiles
     */
    public function __construct(Blacklist $blacklist = null, $includeGlobalVariables = true, $includeStaticAttributes = true, $includeConstants = true, $includeFunctions = true, $includeClasses = true, $includeInterfaces = true, $includeTraits = true, $includeIniSettings = true, $includeIncludedFiles = true)

    {
        if ($blacklist === null) {
            $blacklist = new Blacklist;
        }

        $this->blacklist = $blacklist;

        if ($includeConstants) {
            $this->snapshotConstants();
        }

        if ($includeFunctions) {
            $this->snapshotFunctions();
        }

        if ($includeClasses || $includeStaticAttributes) {
            $this->snapshotClasses();
        }

        if ($includeInterfaces) {
            $this->snapshotInterfaces();
        }

        if ($includeGlobalVariables) {
            $this->setupSuperGlobalArrays();
            $this->snapshotGlobals();
        }

        if ($includeStaticAttributes) {
            $this->snapshotStaticAttributes();
        }

        if ($includeIniSettings) {
            $this->iniSettings = ini_get_all(null, false);
        }

        if ($includeIncludedFiles) {
            $this->includedFiles = get_included_files();
        }

        if (function_exists('get_declared_traits')) {
            $this->traits = get_declared_traits();
        }
    }

    /**
     * @return Blacklist
     */
    public function blacklist()
    {
        return $this->blacklist;
    }

    /**
     * @return array
     */
    public function globalVariables()
    {
        return $this->globalVariables;
    }

    /**
     * @return array
     */
    public function superGlobalVariables()
    {
        return $this->superGlobalVariables;
    }

    /**
     * Returns a list of all super-global variable arrays.
     *
     * @return array
     */
    public function superGlobalArrays()
    {
        return $this->superGlobalArrays;
    }

    /**
     * @return array
     */
    public function staticAttributes()
    {
        return $this->staticAttributes;
    }

    /**
     * @return array
     */
    public function iniSettings()
    {
        return $this->iniSettings;
    }

    /**
     * @return array
     */
    public function includedFiles()
    {
        return $this->includedFiles;
    }

    /**
     * @return array
     */
    public function constants()
    {
        return $this->constants;
    }

    /**
     * @return array
     */
    public function functions()
    {
        return $this->functions;
    }

    /**
     * @return array
     */
    public function interfaces()
    {
        return $this->interfaces;
    }

    /**
     * @return array
     */
    public function classes()
    {
        return $this->classes;
    }

    /**
     * @return array
     */
    public function traits()
    {
        return $this->traits;
    }

    /**
     * Creates a snapshot user-defined constants.
     */
    private function snapshotConstants()
    {
        $constants = get_defined_constants(true);

        if (isset($constants['user'])) {
            $this->constants = $constants['user'];
        }
    }

    /**
     * Creates a snapshot user-defined functions.
     */
    private function snapshotFunctions()
    {
        $functions = get_defined_functions();

        $this->functions = $functions['user'];
    }

    /**
     * Creates a snapshot user-defined classes.
     */
    private function snapshotClasses()

    {
        foreach (array_reverse(get_declared_classes()) as $className) {
            $class = new ReflectionClass($className);

            if (!$class->isUserDefined()) {
                break;
            }

            $this->classes[] = $className;
        }

        $this->classes = array_reverse($this->classes);
    }

    /**
     * Creates a snapshot user-defined interfaces.
     */
    private function snapshotInterfaces()

    {
        foreach (array_reverse(get_declared_interfaces()) as $interfaceName) {
            $class = new ReflectionClass($interfaceName);

            if (!$class->isUserDefined()) {
                break;
            }

            $this->interfaces[] = $interfaceName;
        }

        $this->interfaces = array_reverse($this->interfaces);
    }

    /**
     * Creates a snapshot of all global and super-global variables.
     */
    private function snapshotGlobals()
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        $superGlobalArrays = $this->superGlobalArrays();

        foreach ($superGlobalArrays as $superGlobalArray) {
            $this->snapshotSuperGlobalArray($superGlobalArray);
        }

        foreach (array_keys($GLOBALS) as $key) {
            if ($key != 'GLOBALS' &&
                !in_array($key, $superGlobalArrays) &&
                $this->canBeSerialized($GLOBALS[$key]) &&
                !$this->blacklist->isGlobalVariableBlacklisted($key)) {
                $this->globalVariables[$key] = unserialize(serialize($GLOBALS[$key]));
            }
        }
    }

    /**
     * Creates a snapshot a super-global variable array.
     *
     * @param $superGlobalArray
     */
    private function snapshotSuperGlobalArray($superGlobalArray)
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        $this->superGlobalVariables[$superGlobalArray] = array();

        if (isset($GLOBALS[$superGlobalArray]) && is_array($GLOBALS[$superGlobalArray])) {
            foreach ($GLOBALS[$superGlobalArray] as $key => $value) {
                $this->superGlobalVariables[$superGlobalArray][$key] = unserialize(serialize($value));
            }
        }
    }

    /**
     * Creates a snapshot of all static attributes in user-defined classes.
     */
    private function snapshotStaticAttributes()
    {
        foreach ($this->classes as $className) {
            $class    = new ReflectionClass($className);
            $snapshot = array();

            foreach ($class->getProperties() as $attribute) {
                if ($attribute->isStatic()) {
                    $name = $attribute->getName();

                    if ($this->blacklist->isStaticAttributeBlacklisted($className, $name)) {
                        continue;
                    }

                    $attribute->setAccessible(true);
                    $value = $attribute->getValue();

                    if ($this->canBeSerialized($value)) {
                        $snapshot[$name] = unserialize(serialize($value));
                    }
                }
            }

            if (!empty($snapshot)) {
                $this->staticAttributes[$className] = $snapshot;
            }
        }
    }

    /**
     * Returns a list of all super-global variable arrays.
     *
     * @return array
     */
    private function setupSuperGlobalArrays()
    {
        $this->superGlobalArrays = array(
            '_ENV',
            '_POST',
            '_GET',
            '_COOKIE',
            '_SERVER',
            '_FILES',
            '_REQUEST'
        );

        if (ini_get('register_long_arrays') == '1') {
            $this->superGlobalArrays = array_merge(
                $this->superGlobalArrays,
                array(
                    'HTTP_ENV_VARS',
                    'HTTP_POST_VARS',
                    'HTTP_GET_VARS',
                    'HTTP_COOKIE_VARS',
                    'HTTP_SERVER_VARS',
                    'HTTP_POST_FILES'
                )
            );
        }
    }

    /**
     * @param  mixed $variable
     * @return bool
     * @todo   Implement this properly
     */
    private function canBeSerialized($variable)
    {
        if (!is_object($variable)) {
            return !is_resource($variable);
        }

        if ($variable instanceof \stdClass) {
            return true;
        }

        $class = new ReflectionClass($variable);

        do {
            if ($class->isInternal()) {
                return $variable instanceof Serializable;
            }
        } while ($class = $class->getParentClass());

        return true;
    }
}


1		<?php
2		/*
3		* This file is part of the GlobalState package.
4		*
5		* (c) Sebastian Bergmann <[email protected]>
6		*
7		* For the full copyright and license information, please view the LICENSE
8		* file that was distributed with this source code.
9		*/
10
11		namespace SebastianBergmann\GlobalState;
12
13		use ReflectionClass;
14		use Serializable;
15
16		/**
17		* A snapshot of global state.
18		*/
19		class Snapshot
20		{
21		/**
22		* @var Blacklist
23		*/
24		private $blacklist;
25
26		/**
27		* @var array
28		*/
29		private $globalVariables = array();
30
31		/**
32		* @var array
33		*/
34		private $superGlobalArrays = array();
35
36		/**
37		* @var array
38		*/
39		private $superGlobalVariables = array();
40
41		/**
42		* @var array
43		*/
44		private $staticAttributes = array();
45
46		/**
47		* @var array
48		*/
49		private $iniSettings = array();
50
51		/**
52		* @var array
53		*/
54		private $includedFiles = array();
55
56		/**
57		* @var array
58		*/
59		private $constants = array();
60
61		/**
62		* @var array
63		*/
64		private $functions = array();
65
66		/**
67		* @var array
68		*/
69		private $interfaces = array();
70
71		/**
72		* @var array
73		*/
74		private $classes = array();
75
76		/**
77		* @var array
78		*/
79		private $traits = array();
80
81		/**
82		* Creates a snapshot of the current global state.
83		*
84		* @param Blacklist $blacklist
85		* @param bool $includeGlobalVariables
86		* @param bool $includeStaticAttributes
87		* @param bool $includeConstants
88		* @param bool $includeFunctions
89		* @param bool $includeClasses
90		* @param bool $includeInterfaces
91		* @param bool $includeTraits
92		* @param bool $includeIniSettings
93		* @param bool $includeIncludedFiles
94		*/
95		public function __construct(Blacklist $blacklist = null, $includeGlobalVariables = true, $includeStaticAttributes = true, $includeConstants = true, $includeFunctions = true, $includeClasses = true, $includeInterfaces = true, $includeTraits = true, $includeIniSettings = true, $includeIncludedFiles = true)
		0 ignored issues – show Unused Code introduced 2016-02-13 09:48 UTC by Report Bug Copy Issue Report The parameter `$includeTraits` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
96		{
97		if ($blacklist === null) {
98		$blacklist = new Blacklist;
99		}
100
101		$this->blacklist = $blacklist;
102
103		if ($includeConstants) {
104		$this->snapshotConstants();
105		}
106
107		if ($includeFunctions) {
108		$this->snapshotFunctions();
109		}
110
111		if ($includeClasses \|\| $includeStaticAttributes) {
112		$this->snapshotClasses();
113		}
114
115		if ($includeInterfaces) {
116		$this->snapshotInterfaces();
117		}
118
119		if ($includeGlobalVariables) {
120		$this->setupSuperGlobalArrays();
121		$this->snapshotGlobals();
122		}
123
124		if ($includeStaticAttributes) {
125		$this->snapshotStaticAttributes();
126		}
127
128		if ($includeIniSettings) {
129		$this->iniSettings = ini_get_all(null, false);
130		}
131
132		if ($includeIncludedFiles) {
133		$this->includedFiles = get_included_files();
134		}
135
136		if (function_exists('get_declared_traits')) {
137		$this->traits = get_declared_traits();
138		}
139		}
140
141		/**
142		* @return Blacklist
143		*/
144		public function blacklist()
145		{
146		return $this->blacklist;
147		}
148
149		/**
150		* @return array
151		*/
152		public function globalVariables()
153		{
154		return $this->globalVariables;
155		}
156
157		/**
158		* @return array
159		*/
160		public function superGlobalVariables()
161		{
162		return $this->superGlobalVariables;
163		}
164
165		/**
166		* Returns a list of all super-global variable arrays.
167		*
168		* @return array
169		*/
170		public function superGlobalArrays()
171		{
172		return $this->superGlobalArrays;
173		}
174
175		/**
176		* @return array
177		*/
178		public function staticAttributes()
179		{
180		return $this->staticAttributes;
181		}
182
183		/**
184		* @return array
185		*/
186		public function iniSettings()
187		{
188		return $this->iniSettings;
189		}
190
191		/**
192		* @return array
193		*/
194		public function includedFiles()
195		{
196		return $this->includedFiles;
197		}
198
199		/**
200		* @return array
201		*/
202		public function constants()
203		{
204		return $this->constants;
205		}
206
207		/**
208		* @return array
209		*/
210		public function functions()
211		{
212		return $this->functions;
213		}
214
215		/**
216		* @return array
217		*/
218		public function interfaces()
219		{
220		return $this->interfaces;
221		}
222
223		/**
224		* @return array
225		*/
226		public function classes()
227		{
228		return $this->classes;
229		}
230
231		/**
232		* @return array
233		*/
234		public function traits()
235		{
236		return $this->traits;
237		}
238
239		/**
240		* Creates a snapshot user-defined constants.
241		*/
242		private function snapshotConstants()
243		{
244		$constants = get_defined_constants(true);
245
246		if (isset($constants['user'])) {
247		$this->constants = $constants['user'];
248		}
249		}
250
251		/**
252		* Creates a snapshot user-defined functions.
253		*/
254		private function snapshotFunctions()
255		{
256		$functions = get_defined_functions();
257
258		$this->functions = $functions['user'];
259		}
260
261		/**
262		* Creates a snapshot user-defined classes.
263		*/
264	View Code Duplication	private function snapshotClasses()
		0 ignored issues – show Duplication introduced 2016-02-13 09:48 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...
265		{
266		foreach (array_reverse(get_declared_classes()) as $className) {
267		$class = new ReflectionClass($className);
268
269		if (!$class->isUserDefined()) {
270		break;
271		}
272
273		$this->classes[] = $className;
274		}
275
276		$this->classes = array_reverse($this->classes);
277		}
278
279		/**
280		* Creates a snapshot user-defined interfaces.
281		*/
282	View Code Duplication	private function snapshotInterfaces()
		0 ignored issues – show Duplication introduced 2016-02-13 09:48 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...
283		{
284		foreach (array_reverse(get_declared_interfaces()) as $interfaceName) {
285		$class = new ReflectionClass($interfaceName);
286
287		if (!$class->isUserDefined()) {
288		break;
289		}
290
291		$this->interfaces[] = $interfaceName;
292		}
293
294		$this->interfaces = array_reverse($this->interfaces);
295		}
296
297		/**
298		* Creates a snapshot of all global and super-global variables.
299		*/
300		private function snapshotGlobals()
		0 ignored issues – show Coding Style introduced 2016-02-13 09:48 UTC by Report Bug Copy Issue Report `snapshotGlobals` uses the super-global variable `$GLOBALS` which is generally not recommended. Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad class Router { public function generate($path) { return $_SERVER['HOST'].$path; } } // Better class Router { private $host; public function __construct($host) { $this->host = $host; } public function generate($path) { return $this->host.$path; } } class Controller { public function myAction(Request $request) { // Instead of $page = isset($_GET['page']) ? intval($_GET['page']) : 1; // Better (assuming you use the Symfony2 request) $page = $request->query->get('page', 1); } } Loading history...
301		{
302		$superGlobalArrays = $this->superGlobalArrays();
303
304		foreach ($superGlobalArrays as $superGlobalArray) {
305		$this->snapshotSuperGlobalArray($superGlobalArray);
306		}
307
308		foreach (array_keys($GLOBALS) as $key) {
309		if ($key != 'GLOBALS' &&
310		!in_array($key, $superGlobalArrays) &&
311		$this->canBeSerialized($GLOBALS[$key]) &&
312		!$this->blacklist->isGlobalVariableBlacklisted($key)) {
313		$this->globalVariables[$key] = unserialize(serialize($GLOBALS[$key]));
314		}
315		}
316		}
317
318		/**
319		* Creates a snapshot a super-global variable array.
320		*
321		* @param $superGlobalArray
322		*/
323		private function snapshotSuperGlobalArray($superGlobalArray)
		0 ignored issues – show Coding Style introduced 2016-02-13 09:48 UTC by Report Bug Copy Issue Report `snapshotSuperGlobalArray` uses the super-global variable `$GLOBALS` which is generally not recommended. Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad class Router { public function generate($path) { return $_SERVER['HOST'].$path; } } // Better class Router { private $host; public function __construct($host) { $this->host = $host; } public function generate($path) { return $this->host.$path; } } class Controller { public function myAction(Request $request) { // Instead of $page = isset($_GET['page']) ? intval($_GET['page']) : 1; // Better (assuming you use the Symfony2 request) $page = $request->query->get('page', 1); } } Loading history...
324		{
325		$this->superGlobalVariables[$superGlobalArray] = array();
326
327		if (isset($GLOBALS[$superGlobalArray]) && is_array($GLOBALS[$superGlobalArray])) {
328		foreach ($GLOBALS[$superGlobalArray] as $key => $value) {
329		$this->superGlobalVariables[$superGlobalArray][$key] = unserialize(serialize($value));
330		}
331		}
332		}
333
334		/**
335		* Creates a snapshot of all static attributes in user-defined classes.
336		*/
337		private function snapshotStaticAttributes()
338		{
339		foreach ($this->classes as $className) {
340		$class = new ReflectionClass($className);
341		$snapshot = array();
342
343		foreach ($class->getProperties() as $attribute) {
344		if ($attribute->isStatic()) {
345		$name = $attribute->getName();
346
347		if ($this->blacklist->isStaticAttributeBlacklisted($className, $name)) {
348		continue;
349		}
350
351		$attribute->setAccessible(true);
352		$value = $attribute->getValue();
353
354		if ($this->canBeSerialized($value)) {
355		$snapshot[$name] = unserialize(serialize($value));
356		}
357		}
358		}
359
360		if (!empty($snapshot)) {
361		$this->staticAttributes[$className] = $snapshot;
362		}
363		}
364		}
365
366		/**
367		* Returns a list of all super-global variable arrays.
368		*
369		* @return array
370		*/
371		private function setupSuperGlobalArrays()
372		{
373		$this->superGlobalArrays = array(
374		'_ENV',
375		'_POST',
376		'_GET',
377		'_COOKIE',
378		'_SERVER',
379		'_FILES',
380		'_REQUEST'
381		);
382
383		if (ini_get('register_long_arrays') == '1') {
384		$this->superGlobalArrays = array_merge(
385		$this->superGlobalArrays,
386		array(
387		'HTTP_ENV_VARS',
388		'HTTP_POST_VARS',
389		'HTTP_GET_VARS',
390		'HTTP_COOKIE_VARS',
391		'HTTP_SERVER_VARS',
392		'HTTP_POST_FILES'
393		)
394		);
395		}
396		}
397
398		/**
399		* @param mixed $variable
400		* @return bool
401		* @todo Implement this properly
402		*/
403		private function canBeSerialized($variable)
404		{
405		if (!is_object($variable)) {
406		return !is_resource($variable);
407		}
408
409		if ($variable instanceof \stdClass) {
410		return true;
411		}
412
413		$class = new ReflectionClass($variable);
414
415		do {
416		if ($class->isInternal()) {
417		return $variable instanceof Serializable;
418		}
419		} while ($class = $class->getParentClass());
420
421		return true;
422		}
423		}
424

p6naveen / project-1