InMemoryIndex - Code Metrics - Inspection of "Merge pull request #39 from mkusher/class-reposito..." - mkusher/padawan.php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 81db43...f030be )

by Aleh

created 2016-05-19 12:57 UTC

InMemoryIndex B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	229
Duplicated Lines	14.85 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
wmc	52
c	1
b	0
f	1
lcom	1
cbo	7
dl	34
loc	229
rs	7.9487

21 Methods

Rating	Name	Duplication	Size	Complexity
A	getFQCNs()	0	4	1
A	getImplements()	0	3	1
A	getExtends()	0	3	1
B	addFile()	0	19	5
A	findFileByPath()	0	7	2
A	findFQCNByFile()	0	14	4
A	findClassByFQCN()	9	9	3
A	findInterfaceByFQCN()	9	9	3
A	findFunctionByName()	0	9	3
A	findClassChildren()	8	8	3
A	findInterfaceChildrenClasses()	8	8	3
A	getClasses()	0	8	2
A	getInterfaces()	0	8	2
A	getFunctions()	0	8	2
B	addClass()	0	14	5
A	addInterface()	0	11	4
A	addFunction()	0	4	1
A	addFQCN()	0	3	1
A	addExtend()	0	8	2
A	addImplement()	0	8	2
A	hasCoreIndex()	0	4	2

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

<?php

namespace Padawan\Framework\Domain\Project;

use Padawan\Domain\Project\File;
use Padawan\Domain\Project\FQCN;
use Padawan\Domain\Project\Index;
use Padawan\Domain\Project\Node\ClassData;
use Padawan\Domain\Project\Node\FunctionData;
use Padawan\Domain\Project\Node\InterfaceData;


class InMemoryIndex implements Index
{
    private $files              = [];
    private $fqcns              = [];
    private $classes            = [];
    private $interfaces         = [];
    private $extends            = [];
    private $implements         = [];
    private $functions          = [];

    /** @var Index $coreIndex */
    private static $coreIndex;

    public function getFQCNs()
    {
        return $this->fqcns;
    }

    public function getImplements() {
        return $this->implements;
    }
    public function getExtends() {
        return $this->extends;
    }

    public function addFile(File $file)
    {
        $scope = $file->scope();
        if (empty($scope)) {
            throw new \Exception("Scope in file is empty");
        }
        foreach ($scope->getClasses() as $classData) {
            $this->addFQCN($classData->fqcn);
            $this->addClass($classData);
        }
        foreach ($scope->getInterfaces() as $interfaceData) {
            $this->addFQCN($interfaceData->fqcn);
            $this->addInterface($interfaceData);
        }
        foreach ($scope->getFunctions() as $functionData) {
            $this->addFunction($functionData);
        }
        $this->files[$file->path()] = $file;
    }

    public function findFileByPath($path)
    {
        if (!array_key_exists($path, $this->files)) {
            return null;
        }
        return $this->files[$path];
    }

    /**
     * @return FQCN
     */
    public function findFQCNByFile($file)
    {
        if (!array_key_exists($file, $this->flippedClassMap)) {
class MyClass { }

$x = new MyClass();
$x->foo = true;
            return null;
        }
        $fqcnStr = $this->flippedClassMap[$file];
        if (empty($fqcnStr)) {
            return null;
        }
        if (!array_key_exists($fqcnStr, $this->fqcns)) {
            return null;
        }
        return $this->fqcns[$fqcnStr];
    }

    /**
     * @return ClassData
     */
    public function findClassByFQCN(FQCN $fqcn) {

        $str = $fqcn->toString();
        if (array_key_exists($str, $this->classes)) {
            return $this->classes[$str];
        }
        if ($this->hasCoreIndex()) {
            return self::$coreIndex->findClassByFQCN($fqcn);
        }
    }

    /**
     * @return InterfaceData
     */
    public function findInterfaceByFQCN(FQCN $fqcn) {

        $str = $fqcn->toString();
        if (array_key_exists($str, $this->interfaces)) {
            return $this->interfaces[$str];
        }
        if ($this->hasCoreIndex()) {
            return self::$coreIndex->findInterfaceByFQCN($fqcn);
        }
    }

    /**
     * @return FunctionData
     */
    public function findFunctionByName($functionName)
    {
        if (array_key_exists($functionName, $this->functions)) {
            return $this->functions[$functionName];
        }
        if ($this->hasCoreIndex()) {
            return self::$coreIndex->findFunctionByName($functionName);
        }
    }

    /**
     * @return ClassData[]
     */
    public function findClassChildren(FQCN $class) {

        if (!array_key_exists($class->toString(), $this->extends)
            || !is_array($this->extends[$class->toString()])
        ) {
            $this->extends[$class->toString()] = [];
        }
        return $this->extends[$class->toString()];
    }

    /**
     * @return ClassData[]
     */
    public function findInterfaceChildrenClasses(FQCN $interface) {

        if (!array_key_exists($interface->toString(), $this->implements)
            || !is_array($this->implements[$interface->toString()])
        ) {
            $this->implements[$interface->toString()] = [];
        }
        return $this->implements[$interface->toString()];
    }

    /**
     * @return ClassData[]
     */
    public function getClasses()
    {
        $classes = $this->classes;
        if ($this->hasCoreIndex()) {
            $classes = array_merge($classes, self::$coreIndex->getClasses());
        }
        return $classes;
    }

    /**
     * @return InterfaceData[]
     */
    public function getInterfaces()
    {
        $interfaces = $this->interfaces;
        if ($this->hasCoreIndex()) {
            $interfaces = array_merge($interfaces, self::$coreIndex->getInterfaces());
        }
        return $interfaces;
    }

    /**
     * @return FunctionData[]
     */
    public function getFunctions()
    {
        $functions = $this->functions;
        if ($this->hasCoreIndex()) {
            $functions = array_merge($functions, self::$coreIndex->getFunctions());
        }
        return $functions;
    }

    public function addClass(ClassData $class) {
        $this->classes[$class->fqcn->toString()] = $class;
        if ($class->getParent() instanceof FQCN) {
            $this->addExtend($class, $class->getParent());
        }
        foreach ($class->getInterfaces() as $interface) {
            if ($interface instanceof FQCN) {
                $this->addImplement($class, $interface);
            }
        }
        foreach ($this->findClassChildren($class->fqcn) AS $child) {
            $child->setParent($class);
        }
    }

    public function addInterface(InterfaceData $interface) {
        $this->interfaces[$interface->fqcn->toString()] = $interface;
        foreach ($this->findInterfaceChildrenClasses($interface->fqcn) as $child) {
            $this->addImplement($child, $interface->fqcn);
        }
        foreach ($interface->getInterfaces() as $parent) {
            if ($parent instanceof FQCN) {
                $this->addImplement($interface, $parent);
            }
        }
    }

    public function addFunction(FunctionData $function)
    {
        $this->functions[$function->name] = $function;
    }

    public function addFQCN(FQCN $fqcn) {
        $this->fqcns[$fqcn->toString()] = $fqcn;
    }

    protected function addExtend(ClassData $class, FQCN $parent) {
        $this->findClassChildren($parent);
        $this->extends[$parent->toString()][$class->fqcn->toString()] = $class;
        $parentClass = $this->findClassByFQCN($parent);
        if ($parentClass instanceof ClassData) {
            $class->setParent($parentClass);
        }
    }

    protected function addImplement($class, FQCN $fqcn) {
        $this->findInterfaceChildrenClasses($fqcn);
        $this->implements[$fqcn->toString()][$class->fqcn->toString()] = $class;
        $interface = $this->findInterfaceByFQCN($fqcn);
        if ($interface instanceof InterfaceData) {
            $class->addInterface($interface);
        }
    }

    private function hasCoreIndex()
    {
        return $this !== self::$coreIndex && !empty(self::$coreIndex);
    }
}


1		<?php
2
3		namespace Padawan\Framework\Domain\Project;
4
5		use Padawan\Domain\Project\File;
6		use Padawan\Domain\Project\FQCN;
7		use Padawan\Domain\Project\Index;
8		use Padawan\Domain\Project\Node\ClassData;
9		use Padawan\Domain\Project\Node\FunctionData;
10		use Padawan\Domain\Project\Node\InterfaceData;
11
12
13		class InMemoryIndex implements Index
14		{
15		private $files = [];
16		private $fqcns = [];
17		private $classes = [];
18		private $interfaces = [];
19		private $extends = [];
20		private $implements = [];
21		private $functions = [];
22
23		/** @var Index $coreIndex */
24		private static $coreIndex;
25
26		public function getFQCNs()
27		{
28		return $this->fqcns;
29		}
30
31		public function getImplements() {
32		return $this->implements;
33		}
34		public function getExtends() {
35		return $this->extends;
36		}
37
38		public function addFile(File $file)
39		{
40		$scope = $file->scope();
41		if (empty($scope)) {
42		throw new \Exception("Scope in file is empty");
43		}
44		foreach ($scope->getClasses() as $classData) {
45		$this->addFQCN($classData->fqcn);
46		$this->addClass($classData);
47		}
48		foreach ($scope->getInterfaces() as $interfaceData) {
49		$this->addFQCN($interfaceData->fqcn);
50		$this->addInterface($interfaceData);
51		}
52		foreach ($scope->getFunctions() as $functionData) {
53		$this->addFunction($functionData);
54		}
55		$this->files[$file->path()] = $file;
56		}
57
58		public function findFileByPath($path)
59		{
60		if (!array_key_exists($path, $this->files)) {
61		return null;
62		}
63		return $this->files[$path];
64		}
65
66		/**
67		* @return FQCN
68		*/
69		public function findFQCNByFile($file)
70		{
71		if (!array_key_exists($file, $this->flippedClassMap)) {
		0 ignored issues – show Bug introduced 2016-05-19 12:44 UTC by Report Bug Copy Issue Report The property `flippedClassMap` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
72		return null;
73		}
74		$fqcnStr = $this->flippedClassMap[$file];
75		if (empty($fqcnStr)) {
76		return null;
77		}
78		if (!array_key_exists($fqcnStr, $this->fqcns)) {
79		return null;
80		}
81		return $this->fqcns[$fqcnStr];
82		}
83
84		/**
85		* @return ClassData
86		*/
87	View Code Duplication	public function findClassByFQCN(FQCN $fqcn) {
		0 ignored issues – show Duplication introduced 2016-05-19 12:44 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...
88		$str = $fqcn->toString();
89		if (array_key_exists($str, $this->classes)) {
90		return $this->classes[$str];
91		}
92		if ($this->hasCoreIndex()) {
93		return self::$coreIndex->findClassByFQCN($fqcn);
94		}
95		}
96
97		/**
98		* @return InterfaceData
99		*/
100	View Code Duplication	public function findInterfaceByFQCN(FQCN $fqcn) {
		0 ignored issues – show Duplication introduced 2016-05-19 12:44 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		$str = $fqcn->toString();
102		if (array_key_exists($str, $this->interfaces)) {
103		return $this->interfaces[$str];
104		}
105		if ($this->hasCoreIndex()) {
106		return self::$coreIndex->findInterfaceByFQCN($fqcn);
107		}
108		}
109
110		/**
111		* @return FunctionData
112		*/
113		public function findFunctionByName($functionName)
114		{
115		if (array_key_exists($functionName, $this->functions)) {
116		return $this->functions[$functionName];
117		}
118		if ($this->hasCoreIndex()) {
119		return self::$coreIndex->findFunctionByName($functionName);
120		}
121		}
122
123		/**
124		* @return ClassData[]
125		*/
126	View Code Duplication	public function findClassChildren(FQCN $class) {
		0 ignored issues – show Duplication introduced 2016-05-19 12:44 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...
127		if (!array_key_exists($class->toString(), $this->extends)
128		\|\| !is_array($this->extends[$class->toString()])
129		) {
130		$this->extends[$class->toString()] = [];
131		}
132		return $this->extends[$class->toString()];
133		}
134
135		/**
136		* @return ClassData[]
137		*/
138	View Code Duplication	public function findInterfaceChildrenClasses(FQCN $interface) {
		0 ignored issues – show Duplication introduced 2016-05-19 12:44 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...
139		if (!array_key_exists($interface->toString(), $this->implements)
140		\|\| !is_array($this->implements[$interface->toString()])
141		) {
142		$this->implements[$interface->toString()] = [];
143		}
144		return $this->implements[$interface->toString()];
145		}
146
147		/**
148		* @return ClassData[]
149		*/
150		public function getClasses()
151		{
152		$classes = $this->classes;
153		if ($this->hasCoreIndex()) {
154		$classes = array_merge($classes, self::$coreIndex->getClasses());
155		}
156		return $classes;
157		}
158
159		/**
160		* @return InterfaceData[]
161		*/
162		public function getInterfaces()
163		{
164		$interfaces = $this->interfaces;
165		if ($this->hasCoreIndex()) {
166		$interfaces = array_merge($interfaces, self::$coreIndex->getInterfaces());
167		}
168		return $interfaces;
169		}
170
171		/**
172		* @return FunctionData[]
173		*/
174		public function getFunctions()
175		{
176		$functions = $this->functions;
177		if ($this->hasCoreIndex()) {
178		$functions = array_merge($functions, self::$coreIndex->getFunctions());
179		}
180		return $functions;
181		}
182
183		public function addClass(ClassData $class) {
184		$this->classes[$class->fqcn->toString()] = $class;
185		if ($class->getParent() instanceof FQCN) {
186		$this->addExtend($class, $class->getParent());
187		}
188		foreach ($class->getInterfaces() as $interface) {
189		if ($interface instanceof FQCN) {
190		$this->addImplement($class, $interface);
191		}
192		}
193		foreach ($this->findClassChildren($class->fqcn) AS $child) {
194		$child->setParent($class);
195		}
196		}
197
198		public function addInterface(InterfaceData $interface) {
199		$this->interfaces[$interface->fqcn->toString()] = $interface;
200		foreach ($this->findInterfaceChildrenClasses($interface->fqcn) as $child) {
201		$this->addImplement($child, $interface->fqcn);
202		}
203		foreach ($interface->getInterfaces() as $parent) {
204		if ($parent instanceof FQCN) {
205		$this->addImplement($interface, $parent);
206		}
207		}
208		}
209
210		public function addFunction(FunctionData $function)
211		{
212		$this->functions[$function->name] = $function;
213		}
214
215		public function addFQCN(FQCN $fqcn) {
216		$this->fqcns[$fqcn->toString()] = $fqcn;
217		}
218
219		protected function addExtend(ClassData $class, FQCN $parent) {
220		$this->findClassChildren($parent);
221		$this->extends[$parent->toString()][$class->fqcn->toString()] = $class;
222		$parentClass = $this->findClassByFQCN($parent);
223		if ($parentClass instanceof ClassData) {
224		$class->setParent($parentClass);
225		}
226		}
227
228		protected function addImplement($class, FQCN $fqcn) {
229		$this->findInterfaceChildrenClasses($fqcn);
230		$this->implements[$fqcn->toString()][$class->fqcn->toString()] = $class;
231		$interface = $this->findInterfaceByFQCN($fqcn);
232		if ($interface instanceof InterfaceData) {
233		$class->addInterface($interface);
234		}
235		}
236
237		private function hasCoreIndex()
238		{
239		return $this !== self::$coreIndex && !empty(self::$coreIndex);
240		}
241		}
242

mkusher / padawan.php