DefaultPersistentCollectionGenerator::generateCollectionClass() - Code Metrics - Inspection of "[WIP] Update to Doctrine CS 5.0" - doctrine/mongodb-odm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#1860)

by Andreas

created 2018-09-02 08:38 UTC

generateCollectionClass() C

↳ Parent: DefaultPersistentCollectionGenerator

Complexity

Conditions	11
Paths	15

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	26
CRAP Score	11.044

Importance

Changes

Metric	Value
dl	0
loc	71
ccs	26
cts	28
cp	0.9286
rs	6.486
c	0
b	0
f	0
cc	11
nc	15
nop	3
crap	11.044

How to fix Long Method Complexity

<?php

declare(strict_types=1);

namespace Doctrine\ODM\MongoDB\PersistentCollection;

use Doctrine\ODM\MongoDB\Configuration;
use ReflectionClass;
use ReflectionException;
use ReflectionMethod;
use ReflectionParameter;
use ReflectionType;
use const DIRECTORY_SEPARATOR;
use function array_map;
use function array_pop;
use function class_exists;
use function dirname;
use function explode;
use function file_exists;
use function file_put_contents;
use function implode;
use function interface_exists;
use function is_dir;
use function is_writable;
use function method_exists;
use function mkdir;
use function rename;
use function str_replace;
use function strtolower;
use function substr;
use function uniqid;
use function var_export;

/**
 * Default generator for custom PersistentCollection classes.
 *
 */
final class DefaultPersistentCollectionGenerator implements PersistentCollectionGenerator
{
    /**
     * The namespace that contains all persistent collection classes.
     *
     * @var string
     */
    private $collectionNamespace;

    /**
     * The directory that contains all persistent collection classes.
     *
     * @var string
     */
    private $collectionDir;

    public function __construct(string $collectionDir, string $collectionNs)
    {
        $this->collectionDir = $collectionDir;
        $this->collectionNamespace = $collectionNs;
    }

    /**
     * {@inheritdoc}
     */
    public function generateClass(string $class, string $dir) : void
    {
        $collClassName = str_replace('\\', '', $class) . 'Persistent';
        $className = $this->collectionNamespace . '\\' . $collClassName;
        $fileName = $dir . DIRECTORY_SEPARATOR . $collClassName . '.php';
        $this->generateCollectionClass($class, $className, $fileName);
    }

    /**
     * {@inheritdoc}
     */
    public function loadClass(string $collectionClass, int $autoGenerate) : string
    {
        // These checks are not in __construct() because of BC and should be moved for 2.0
        if (! $this->collectionDir) {
            throw PersistentCollectionException::directoryRequired();
        }
        if (! $this->collectionNamespace) {
            throw PersistentCollectionException::namespaceRequired();
        }

        $collClassName = str_replace('\\', '', $collectionClass) . 'Persistent';
        $className = $this->collectionNamespace . '\\' . $collClassName;
        if (! class_exists($className, false)) {
            $fileName = $this->collectionDir . DIRECTORY_SEPARATOR . $collClassName . '.php';
            switch ($autoGenerate) {
                case Configuration::AUTOGENERATE_NEVER:
                    require $fileName;
                    break;

                case Configuration::AUTOGENERATE_ALWAYS:
                    $this->generateCollectionClass($collectionClass, $className, $fileName);
                    require $fileName;
                    break;

                case Configuration::AUTOGENERATE_FILE_NOT_EXISTS:
                    if (! file_exists($fileName)) {
                        $this->generateCollectionClass($collectionClass, $className, $fileName);
                    }
                    require $fileName;
                    break;

                case Configuration::AUTOGENERATE_EVAL:
                    $this->generateCollectionClass($collectionClass, $className, false);
                    break;
            }
        }

        return $className;
    }

    /**
     * @param string|false $fileName Filename to write collection class code or false to eval it.
     */
    private function generateCollectionClass(string $for, string $targetFqcn, $fileName)
    {
        $exploded = explode('\\', $targetFqcn);
        $class = array_pop($exploded);
        $namespace = implode('\\', $exploded);
        $code = <<<CODE
<?php

namespace $namespace;

use Doctrine\Common\Collections\Collection as BaseCollection;
use Doctrine\ODM\MongoDB\DocumentManager;
use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
use Doctrine\ODM\MongoDB\MongoDBException;
use Doctrine\ODM\MongoDB\UnitOfWork;
use Doctrine\ODM\MongoDB\Utility\CollectionHelper;

/**
 * DO NOT EDIT THIS FILE - IT WAS CREATED BY DOCTRINE\'S PERSISTENT COLLECTION GENERATOR
 */
class $class extends \\$for implements \\Doctrine\\ODM\\MongoDB\\PersistentCollection\\PersistentCollectionInterface
{
    use \\Doctrine\\ODM\\MongoDB\\PersistentCollection\\PersistentCollectionTrait;

    /**
     * @param BaseCollection \$coll
     * @param DocumentManager \$dm
     * @param UnitOfWork \$uow
     */
    public function __construct(BaseCollection \$coll, DocumentManager \$dm, UnitOfWork \$uow)
    {
        \$this->coll = \$coll;
        \$this->dm = \$dm;
        \$this->uow = \$uow;
    }

CODE;
        $rc = new ReflectionClass($for);
        $rt = new ReflectionClass('Doctrine\\ODM\\MongoDB\\PersistentCollection\\PersistentCollectionTrait');
        foreach ($rc->getMethods(ReflectionMethod::IS_PUBLIC) as $method) {
            if ($rt->hasMethod($method->name) ||
                $method->isConstructor() ||
                $method->isFinal() ||
                $method->isStatic()
            ) {
                continue;
            }
            $code .= $this->generateMethod($method);
        }
        $code .= "}\n";

        if ($fileName === false) {
            if (! class_exists($targetFqcn)) {
                eval(substr($code, 5));
            }
        } else {
            $parentDirectory = dirname($fileName);

            if (! is_dir($parentDirectory) && (@mkdir($parentDirectory, 0775, true) === false)) {
                throw PersistentCollectionException::directoryNotWritable();
            }

            if (! is_writable($parentDirectory)) {
                throw PersistentCollectionException::directoryNotWritable();
            }

            $tmpFileName = $fileName . '.' . uniqid('', true);
            file_put_contents($tmpFileName, $code);
            rename($tmpFileName, $fileName);
        }
    }

    private function generateMethod(ReflectionMethod $method) : string
    {
        $parametersString = $this->buildParametersString($method);
        $callParamsString = implode(', ', $this->getParameterNamesForDecoratedCall($method->getParameters()));

        return <<<CODE

    /**
     * {@inheritDoc}
     */
    public function {$method->name}($parametersString){$this->getMethodReturnType($method)}
    {
        \$this->initialize();
        if (\$this->needsSchedulingForDirtyCheck()) {
            \$this->changed();
        }
        return \$this->coll->{$method->name}($callParamsString);
    }

CODE;
    }

    private function buildParametersString(ReflectionMethod $method) : string
    {
        $parameters = $method->getParameters();
        $parameterDefinitions = [];

        /** @var ReflectionParameter $param */
        foreach ($parameters as $param) {
            $parameterDefinition = '';
            $parameterType = $this->getParameterType($param);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

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

            if ($parameterType) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                $parameterDefinition .= $parameterType . ' ';
            }

            if ($param->isPassedByReference()) {
                $parameterDefinition .= '&';
            }

            if (method_exists($param, 'isVariadic')) {
                if ($param->isVariadic()) {
                    $parameterDefinition .= '...';
                }
            }

            $parameters[]     = '$' . $param->name;
            $parameterDefinition .= '$' . $param->name;

            if ($param->isDefaultValueAvailable()) {
                $parameterDefinition .= ' = ' . var_export($param->getDefaultValue(), true);
            }

            $parameterDefinitions[] = $parameterDefinition;
        }

        return implode(', ', $parameterDefinitions);
    }

    private function getParameterType(ReflectionParameter $parameter) : ?string
    {
        // We need to pick the type hint class too
        if ($parameter->isArray()) {
            return 'array';
        }

        if (method_exists($parameter, 'isCallable') && $parameter->isCallable()) {
            return 'callable';
        }

        try {
            $parameterClass = $parameter->getClass();

            if ($parameterClass) {
                return '\\' . $parameterClass->name;
            }
        } catch (ReflectionException $previous) {
            // @todo ProxyGenerator throws specialized exceptions
            throw $previous;
        }

        return null;
    }

    /**
     * @param ReflectionParameter[] $parameters
     *
     * @return string[]
     */
    private function getParameterNamesForDecoratedCall(array $parameters) : array
    {
        return array_map(
            static function (ReflectionParameter $parameter) {
                $name = '';

                if (method_exists($parameter, 'isVariadic')) {
                    if ($parameter->isVariadic()) {
                        $name .= '...';
                    }
                }

                return $name . '$' . $parameter->name;
            },
            $parameters
        );
    }

    /**
     * @see \Doctrine\Common\Proxy\ProxyGenerator::getMethodReturnType()
     */
    private function getMethodReturnType(ReflectionMethod $method) : string
    {
        if (! method_exists($method, 'hasReturnType') || ! $method->hasReturnType()) {
            return '';
        }
        return ': ' . $this->formatType($method->getReturnType(), $method);
    }

    /**
     * @see \Doctrine\Common\Proxy\ProxyGenerator::formatType()
     */
    private function formatType(
        ReflectionType $type,
        ReflectionMethod $method,
        ?ReflectionParameter $parameter = null
    ) : string {
        $name = method_exists($type, 'getName') ? $type->getName() : (string) $type;
        $nameLower = strtolower($name);
        if ($nameLower === 'self') {
            $name = $method->getDeclaringClass()->getName();

        }
        if ($nameLower === 'parent') {
            $name = $method->getDeclaringClass()->getParentClass()->getName();
        }
        if (! $type->isBuiltin() && ! class_exists($name) && ! interface_exists($name)) {
            if ($parameter !== null) {
                throw PersistentCollectionException::invalidParameterTypeHint(
                    $method->getDeclaringClass()->getName(),

                    $method->getName(),

                    $parameter->getName()
                );
            }
            throw PersistentCollectionException::invalidReturnTypeHint(
                $method->getDeclaringClass()->getName(),

                $method->getName()

            );
        }
        if (! $type->isBuiltin()) {
            $name = '\\' . $name;
        }
        if ($type->allowsNull()
            && ($parameter === null || ! $parameter->isDefaultValueAvailable() || $parameter->getDefaultValue() !== null)
        ) {
            $name = '?' . $name;
        }
        return $name;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Doctrine\ODM\MongoDB\PersistentCollection;
6
7		use Doctrine\ODM\MongoDB\Configuration;
8		use ReflectionClass;
9		use ReflectionException;
10		use ReflectionMethod;
11		use ReflectionParameter;
12		use ReflectionType;
13		use const DIRECTORY_SEPARATOR;
14		use function array_map;
15		use function array_pop;
16		use function class_exists;
17		use function dirname;
18		use function explode;
19		use function file_exists;
20		use function file_put_contents;
21		use function implode;
22		use function interface_exists;
23		use function is_dir;
24		use function is_writable;
25		use function method_exists;
26		use function mkdir;
27		use function rename;
28		use function str_replace;
29		use function strtolower;
30		use function substr;
31		use function uniqid;
32		use function var_export;
33
34		/**
35		* Default generator for custom PersistentCollection classes.
36		*
37		*/
38		final class DefaultPersistentCollectionGenerator implements PersistentCollectionGenerator
39		{
40		/**
41		* The namespace that contains all persistent collection classes.
42		*
43		* @var string
44		*/
45		private $collectionNamespace;
46
47		/**
48		* The directory that contains all persistent collection classes.
49		*
50		* @var string
51		*/
52		private $collectionDir;
53
54	11	public function __construct(string $collectionDir, string $collectionNs)
55		{
56	11	$this->collectionDir = $collectionDir;
57	11	$this->collectionNamespace = $collectionNs;
58	11	}
59
60		/**
61		* {@inheritdoc}
62		*/
63		public function generateClass(string $class, string $dir) : void
64		{
65		$collClassName = str_replace('\\', '', $class) . 'Persistent';
66		$className = $this->collectionNamespace . '\\' . $collClassName;
67		$fileName = $dir . DIRECTORY_SEPARATOR . $collClassName . '.php';
68		$this->generateCollectionClass($class, $className, $fileName);
69		}
70
71		/**
72		* {@inheritdoc}
73		*/
74	10	public function loadClass(string $collectionClass, int $autoGenerate) : string
75		{
76		// These checks are not in __construct() because of BC and should be moved for 2.0
77	10	if (! $this->collectionDir) {
78		throw PersistentCollectionException::directoryRequired();
79		}
80	10	if (! $this->collectionNamespace) {
81		throw PersistentCollectionException::namespaceRequired();
82		}
83
84	10	$collClassName = str_replace('\\', '', $collectionClass) . 'Persistent';
85	10	$className = $this->collectionNamespace . '\\' . $collClassName;
86	10	if (! class_exists($className, false)) {
87	6	$fileName = $this->collectionDir . DIRECTORY_SEPARATOR . $collClassName . '.php';
88	6	switch ($autoGenerate) {
89		case Configuration::AUTOGENERATE_NEVER:
90		require $fileName;
91		break;
92
93		case Configuration::AUTOGENERATE_ALWAYS:
94	3	$this->generateCollectionClass($collectionClass, $className, $fileName);
95	3	require $fileName;
96	3	break;
97
98		case Configuration::AUTOGENERATE_FILE_NOT_EXISTS:
99		if (! file_exists($fileName)) {
100		$this->generateCollectionClass($collectionClass, $className, $fileName);
101		}
102		require $fileName;
103		break;
104
105		case Configuration::AUTOGENERATE_EVAL:
106	3	$this->generateCollectionClass($collectionClass, $className, false);
107	3	break;
108		}
109		}
110
111	10	return $className;
112		}
113
114		/**
115		* @param string\|false $fileName Filename to write collection class code or false to eval it.
116		*/
117	6	private function generateCollectionClass(string $for, string $targetFqcn, $fileName)
118		{
119	6	$exploded = explode('\\', $targetFqcn);
120	6	$class = array_pop($exploded);
121	6	$namespace = implode('\\', $exploded);
122		$code = <<<CODE
123		<?php
124
125	6	namespace $namespace;
126
127		use Doctrine\Common\Collections\Collection as BaseCollection;
128		use Doctrine\ODM\MongoDB\DocumentManager;
129		use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
130		use Doctrine\ODM\MongoDB\MongoDBException;
131		use Doctrine\ODM\MongoDB\UnitOfWork;
132		use Doctrine\ODM\MongoDB\Utility\CollectionHelper;
133
134		/**
135		* DO NOT EDIT THIS FILE - IT WAS CREATED BY DOCTRINE\'S PERSISTENT COLLECTION GENERATOR
136		*/
137	6	class $class extends \\$for implements \\Doctrine\\ODM\\MongoDB\\PersistentCollection\\PersistentCollectionInterface
138		{
139		use \\Doctrine\\ODM\\MongoDB\\PersistentCollection\\PersistentCollectionTrait;
140
141		/**
142		* @param BaseCollection \$coll
143		* @param DocumentManager \$dm
144		* @param UnitOfWork \$uow
145		*/
146		public function __construct(BaseCollection \$coll, DocumentManager \$dm, UnitOfWork \$uow)
147		{
148		\$this->coll = \$coll;
149		\$this->dm = \$dm;
150		\$this->uow = \$uow;
151		}
152
153		CODE;
154	6	$rc = new ReflectionClass($for);
155	6	$rt = new ReflectionClass('Doctrine\\ODM\\MongoDB\\PersistentCollection\\PersistentCollectionTrait');
156	6	foreach ($rc->getMethods(ReflectionMethod::IS_PUBLIC) as $method) {
157	6	if ($rt->hasMethod($method->name) \|\|
158	6	$method->isConstructor() \|\|
159	6	$method->isFinal() \|\|
160	6	$method->isStatic()
161		) {
162	6	continue;
163		}
164	6	$code .= $this->generateMethod($method);
165		}
166	6	$code .= "}\n";
167
168	6	if ($fileName === false) {
169	3	if (! class_exists($targetFqcn)) {
170	3	eval(substr($code, 5));
171		}
172		} else {
173	3	$parentDirectory = dirname($fileName);
174
175	3	if (! is_dir($parentDirectory) && (@mkdir($parentDirectory, 0775, true) === false)) {
176		throw PersistentCollectionException::directoryNotWritable();
177		}
178
179	3	if (! is_writable($parentDirectory)) {
180		throw PersistentCollectionException::directoryNotWritable();
181		}
182
183	3	$tmpFileName = $fileName . '.' . uniqid('', true);
184	3	file_put_contents($tmpFileName, $code);
185	3	rename($tmpFileName, $fileName);
186		}
187	6	}
188
189	6	private function generateMethod(ReflectionMethod $method) : string
190		{
191	6	$parametersString = $this->buildParametersString($method);
192	6	$callParamsString = implode(', ', $this->getParameterNamesForDecoratedCall($method->getParameters()));
193
194		return <<<CODE
195
196		/**
197		* {@inheritDoc}
198		*/
199	6	public function {$method->name}($parametersString){$this->getMethodReturnType($method)}
200		{
201		\$this->initialize();
202		if (\$this->needsSchedulingForDirtyCheck()) {
203		\$this->changed();
204		}
205	6	return \$this->coll->{$method->name}($callParamsString);
206		}
207
208		CODE;
209		}
210
211	6	private function buildParametersString(ReflectionMethod $method) : string
212		{
213	6	$parameters = $method->getParameters();
214	6	$parameterDefinitions = [];
215
216		/** @var ReflectionParameter $param */
217	6	foreach ($parameters as $param) {
218	6	$parameterDefinition = '';
219	6	$parameterType = $this->getParameterType($param);
		0 ignored issues – show Bug introduced 2016-02-10 22:25 UTC by Report Bug Copy Issue Report It seems like `$param` defined by `$param` on line `217` can also be of type `string`; however, `Doctrine\ODM\MongoDB\Per...tor::getParameterType()` does only seem to accept `object<ReflectionParameter>`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
220
221	6	if ($parameterType) {
		0 ignored issues – show Bug Best Practice introduced 2018-03-09 11:38 UTC by Report Bug Copy Issue Report The expression `$parameterType` of type `string\|null` is loosely compared to `true`; this is ambiguous if the string can be empty. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
222	6	$parameterDefinition .= $parameterType . ' ';
223		}
224
225	6	if ($param->isPassedByReference()) {
226		$parameterDefinition .= '&';
227		}
228
229	6	if (method_exists($param, 'isVariadic')) {
230	6	if ($param->isVariadic()) {
231		$parameterDefinition .= '...';
232		}
233		}
234
235	6	$parameters[] = '$' . $param->name;
236	6	$parameterDefinition .= '$' . $param->name;
237
238	6	if ($param->isDefaultValueAvailable()) {
239		$parameterDefinition .= ' = ' . var_export($param->getDefaultValue(), true);
240		}
241
242	6	$parameterDefinitions[] = $parameterDefinition;
243		}
244
245	6	return implode(', ', $parameterDefinitions);
246		}
247
248	6	private function getParameterType(ReflectionParameter $parameter) : ?string
249		{
250		// We need to pick the type hint class too
251	6	if ($parameter->isArray()) {
252		return 'array';
253		}
254
255	6	if (method_exists($parameter, 'isCallable') && $parameter->isCallable()) {
256		return 'callable';
257		}
258
259		try {
260	6	$parameterClass = $parameter->getClass();
261
262	6	if ($parameterClass) {
263	6	return '\\' . $parameterClass->name;
264		}
265		} catch (ReflectionException $previous) {
266		// @todo ProxyGenerator throws specialized exceptions
267		throw $previous;
268		}
269
270	2	return null;
271		}
272
273		/**
274		* @param ReflectionParameter[] $parameters
275		*
276		* @return string[]
277		*/
278	6	private function getParameterNamesForDecoratedCall(array $parameters) : array
279		{
280	6	return array_map(
281		static function (ReflectionParameter $parameter) {
282	6	$name = '';
283
284	6	if (method_exists($parameter, 'isVariadic')) {
285	6	if ($parameter->isVariadic()) {
286		$name .= '...';
287		}
288		}
289
290	6	return $name . '$' . $parameter->name;
291	6	},
292	6	$parameters
293		);
294		}
295
296		/**
297		* @see \Doctrine\Common\Proxy\ProxyGenerator::getMethodReturnType()
298		*/
299	6	private function getMethodReturnType(ReflectionMethod $method) : string
300		{
301	6	if (! method_exists($method, 'hasReturnType') \|\| ! $method->hasReturnType()) {
302	6	return '';
303		}
304	2	return ': ' . $this->formatType($method->getReturnType(), $method);
305		}
306
307		/**
308		* @see \Doctrine\Common\Proxy\ProxyGenerator::formatType()
309		*/
310	2	private function formatType(
311		ReflectionType $type,
312		ReflectionMethod $method,
313		?ReflectionParameter $parameter = null
314		) : string {
315	2	$name = method_exists($type, 'getName') ? $type->getName() : (string) $type;
316	2	$nameLower = strtolower($name);
317	2	if ($nameLower === 'self') {
318		$name = $method->getDeclaringClass()->getName();
		0 ignored issues – show introduced 2016-12-07 01:20 UTC by Report Bug Copy Issue Report Consider using `$method->class`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
319		}
320	2	if ($nameLower === 'parent') {
321		$name = $method->getDeclaringClass()->getParentClass()->getName();
322		}
323	2	if (! $type->isBuiltin() && ! class_exists($name) && ! interface_exists($name)) {
324		if ($parameter !== null) {
325		throw PersistentCollectionException::invalidParameterTypeHint(
326		$method->getDeclaringClass()->getName(),
		0 ignored issues – show introduced 2017-01-14 17:49 UTC by Report Bug Copy Issue Report Consider using `$method->class`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
327		$method->getName(),
		0 ignored issues – show Bug introduced 2016-12-07 01:20 UTC by Report Bug Copy Issue Report Consider using `$method->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
328		$parameter->getName()
329		);
330		}
331		throw PersistentCollectionException::invalidReturnTypeHint(
332		$method->getDeclaringClass()->getName(),
		0 ignored issues – show introduced 2017-01-14 17:49 UTC by Report Bug Copy Issue Report Consider using `$method->class`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
333		$method->getName()
		0 ignored issues – show Bug introduced 2016-12-07 01:20 UTC by Report Bug Copy Issue Report Consider using `$method->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
334		);
335		}
336	2	if (! $type->isBuiltin()) {
337	2	$name = '\\' . $name;
338		}
339	2	if ($type->allowsNull()
340	2	&& ($parameter === null \|\| ! $parameter->isDefaultValueAvailable() \|\| $parameter->getDefaultValue() !== null)
341		) {
342	1	$name = '?' . $name;
343		}
344	2	return $name;
345		}
346		}
347

doctrine / mongodb-odm

Pull Request — master (#1860)

generateCollectionClass() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like