Factory::getPassesMetadata() - Code Metrics - Inspection of "Improving regex for valid and invalid placeholders..." - ovr/phpsa - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 031f6e...a91da6 )

by Дмитрий

created 2017-11-11 08:42 UTC

Factory::getPassesMetadata() A

↳ Parent: Factory

Complexity

Conditions	4
Paths	8

Size

Total Lines	18
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	12
CRAP Score	4

Importance

Changes

Metric	Value
cc	4
eloc	9
nc	8
nop	0
dl	0
loc	18
ccs	12
cts	12
cp	1
crap	4
rs	9.2
c	0
b	0
f	0

<?php
/**
 * @author Patsura Dmitry https://github.com/ovr <[email protected]>
 */

namespace PHPSA\Analyzer;

use PHPSA\Analyzer;
use PHPSA\Configuration;
use Symfony\Component\Config\Definition\Builder\NodeDefinition;
use Webiny\Component\EventManager\EventManager;
use PHPSA\Analyzer\Pass as AnalyzerPass;

class Factory
{
    /**
     * @return NodeDefinition[]
     */
    public static function getPassesConfigurations()
    {
        $configs = [];

        foreach (self::getExpressionPasses() as $passClass) {
            $configs[] = $passClass::getMetadata()->getConfiguration();
        }

        foreach (self::getStatementPasses() as $passClass) {
            $configs[] = $passClass::getMetadata()->getConfiguration();
        }

        foreach (self::getScalarPasses() as $passClass) {
            $configs[] = $passClass::getMetadata()->getConfiguration();
        }

        return $configs;
    }

    /**
     * @return \PHPSA\Analyzer\Pass\Metadata[]
     */
    public static function getPassesMetadata()
    {
        $meta = [];

        foreach (self::getExpressionPasses() as $passClass) {
            $meta[] = $passClass::getMetadata();
        }

        foreach (self::getStatementPasses() as $passClass) {
            $meta[] = $passClass::getMetadata();
        }

        foreach (self::getScalarPasses() as $passClass) {
            $meta[] = $passClass::getMetadata();
        }

        return $meta;
    }

    /**
     * @param EventManager $eventManager
     * @param Configuration $config
     * @return Analyzer
     */
    public static function factory(EventManager $eventManager, Configuration $config)

    {
        $analyzersConfig = $config->getValue('analyzers');

        $filterEnabled = function ($passClass) use ($config, $analyzersConfig) {
            /** @var AnalyzerPass\Metadata $passMetadata */
            $passMetadata = $passClass::getMetadata();

            if (!isset($analyzersConfig[$passMetadata->getName()])) {
                return false;
            }

            if (!$analyzersConfig[$passMetadata->getName()]['enabled']) {
                return false;
            }

            if (!$passMetadata->allowsPhpVersion($config->getValue('language_level'))) {
                return false;
            }

            return true;
        };

        $instanciate = function ($passClass) use ($analyzersConfig) {
            $passName = $passClass::getMetadata()->getName();
            
            return new $passClass($analyzersConfig[$passName]);
        };

        $analyzer = new Analyzer($eventManager);
        $analyzer->registerExpressionPasses(
            array_map($instanciate, array_filter(self::getExpressionPasses(), $filterEnabled))
        );
        $analyzer->registerStatementPasses(
            array_map($instanciate, array_filter(self::getStatementPasses(), $filterEnabled))
        );
        $analyzer->registerScalarPasses(
            array_map($instanciate, array_filter(self::getScalarPasses(), $filterEnabled))
        );
        $analyzer->bind();

        return $analyzer;
    }

    /**
     * @return array
     */
    private static function getStatementPasses()
    {
        return [
            AnalyzerPass\Statement\MagicMethodParameters::class,
            AnalyzerPass\Statement\GotoUsage::class,
            AnalyzerPass\Statement\GlobalUsage::class,
            AnalyzerPass\Statement\HasMoreThanOneProperty::class,
            AnalyzerPass\Statement\MissingBreakStatement::class,
            AnalyzerPass\Statement\MissingVisibility::class,
            AnalyzerPass\Statement\MethodCannotReturn::class,
            AnalyzerPass\Statement\UnexpectedUseOfThis::class,
            AnalyzerPass\Statement\TestAnnotation::class,
            AnalyzerPass\Statement\MissingDocblock::class,
            AnalyzerPass\Statement\OldConstructor::class,
            AnalyzerPass\Statement\ConstantNaming::class,
            AnalyzerPass\Statement\MissingBody::class,
            AnalyzerPass\Statement\InlineHtmlUsage::class,
            AnalyzerPass\Statement\AssignmentInCondition::class,
            AnalyzerPass\Statement\StaticUsage::class,
            AnalyzerPass\Statement\OptionalParamBeforeRequired::class,
            AnalyzerPass\Statement\YodaCondition::class,
            AnalyzerPass\Statement\ForCondition::class,
            AnalyzerPass\Statement\PropertyDefinitionDefaultValue::class,
            AnalyzerPass\Statement\ReturnAndYieldInOneMethod::class,
            AnalyzerPass\Statement\ReturnVoid::class,
        ];
    }

    /**
     * @return array
     */
    private static function getExpressionPasses()
    {
        return [
            // Another
            AnalyzerPass\Expression\ErrorSuppression::class,
            AnalyzerPass\Expression\MultipleUnaryOperators::class,
            AnalyzerPass\Expression\StupidUnaryOperators::class,
            AnalyzerPass\Expression\VariableVariableUsage::class,
            AnalyzerPass\Expression\Casts::class,
            AnalyzerPass\Expression\EvalUsage::class,
            AnalyzerPass\Expression\FinalStaticUsage::class,
            AnalyzerPass\Expression\CompareWithArray::class,
            AnalyzerPass\Expression\DivisionFromZero::class,
            AnalyzerPass\Expression\DivisionByOne::class,
            AnalyzerPass\Expression\BacktickUsage::class,
            AnalyzerPass\Expression\LogicInversion::class,
            AnalyzerPass\Expression\ExitUsage::class,
            AnalyzerPass\Expression\NestedTernary::class,
            AnalyzerPass\Expression\AssignRefNew::class,
            // Arrays
            AnalyzerPass\Expression\ArrayShortDefinition::class,
            AnalyzerPass\Expression\ArrayDuplicateKeys::class,
            AnalyzerPass\Expression\ArrayIllegalOffsetType::class,
            // Function call
            AnalyzerPass\Expression\FunctionCall\AliasCheck::class,
            AnalyzerPass\Expression\FunctionCall\DebugCode::class,
            AnalyzerPass\Expression\FunctionCall\RandomApiMigration::class,
            AnalyzerPass\Expression\FunctionCall\SleepUsage::class,
            AnalyzerPass\Expression\FunctionCall\UseCast::class,
            AnalyzerPass\Expression\FunctionCall\DeprecatedIniOptions::class,
            AnalyzerPass\Expression\FunctionCall\RegularExpressions::class,
            AnalyzerPass\Expression\FunctionCall\ArgumentUnpacking::class,
            AnalyzerPass\Expression\FunctionCall\UnsafeUnserialize::class,
            AnalyzerPass\Expression\FunctionCall\DeprecatedFunctions::class,
            AnalyzerPass\Expression\FunctionCall\FunctionStringFormater::class,
        ];
    }

    /**
     * @return array
     */
    private static function getScalarPasses()
    {
        return [
            AnalyzerPass\Scalar\CheckLNumberKind::class,
        ];
    }
}


1		<?php
2		/**
3		* @author Patsura Dmitry https://github.com/ovr <[email protected]>
4		*/
5
6		namespace PHPSA\Analyzer;
7
8		use PHPSA\Analyzer;
9		use PHPSA\Configuration;
10		use Symfony\Component\Config\Definition\Builder\NodeDefinition;
11		use Webiny\Component\EventManager\EventManager;
12		use PHPSA\Analyzer\Pass as AnalyzerPass;
13
14		class Factory
15		{
16		/**
17		* @return NodeDefinition[]
18		*/
19	3	public static function getPassesConfigurations()
20		{
21	2	$configs = [];
22
23	2	foreach (self::getExpressionPasses() as $passClass) {
24	2	$configs[] = $passClass::getMetadata()->getConfiguration();
25	2	}
26
27	3	foreach (self::getStatementPasses() as $passClass) {
28	2	$configs[] = $passClass::getMetadata()->getConfiguration();
29	2	}
30
31	2	foreach (self::getScalarPasses() as $passClass) {
32	2	$configs[] = $passClass::getMetadata()->getConfiguration();
33	2	}
34
35	2	return $configs;
36		}
37
38		/**
39		* @return \PHPSA\Analyzer\Pass\Metadata[]
40		*/
41	1	public static function getPassesMetadata()
42		{
43	1	$meta = [];
44
45	1	foreach (self::getExpressionPasses() as $passClass) {
46	1	$meta[] = $passClass::getMetadata();
47	1	}
48
49	1	foreach (self::getStatementPasses() as $passClass) {
50	1	$meta[] = $passClass::getMetadata();
51	1	}
52
53	1	foreach (self::getScalarPasses() as $passClass) {
54	1	$meta[] = $passClass::getMetadata();
55	1	}
56
57	1	return $meta;
58		}
59
60		/**
61		* @param EventManager $eventManager
62		* @param Configuration $config
63		* @return Analyzer
64		*/
65	52	public static function factory(EventManager $eventManager, Configuration $config)
		0 ignored issues – show Best Practice introduced 2016-09-17 17:35 UTC by Report Bug Copy Issue Report Using PHP4-style constructors that are named like the class is not recommend; better use the more explicit `__construct` method. Loading history...
66		{
67	52	$analyzersConfig = $config->getValue('analyzers');
68
69		$filterEnabled = function ($passClass) use ($config, $analyzersConfig) {
70		/** @var AnalyzerPass\Metadata $passMetadata */
71	52	$passMetadata = $passClass::getMetadata();
72
73	52	if (!isset($analyzersConfig[$passMetadata->getName()])) {
74	51	return false;
75		}
76
77	52	if (!$analyzersConfig[$passMetadata->getName()]['enabled']) {
78		return false;
79		}
80
81	52	if (!$passMetadata->allowsPhpVersion($config->getValue('language_level'))) {
82		return false;
83		}
84
85	52	return true;
86	52	};
87
88	52	$instanciate = function ($passClass) use ($analyzersConfig) {
89	52	$passName = $passClass::getMetadata()->getName();
90
91	52	return new $passClass($analyzersConfig[$passName]);
92	52	};
93
94	52	$analyzer = new Analyzer($eventManager);
95	52	$analyzer->registerExpressionPasses(
96	52	array_map($instanciate, array_filter(self::getExpressionPasses(), $filterEnabled))
97	52	);
98	52	$analyzer->registerStatementPasses(
99	52	array_map($instanciate, array_filter(self::getStatementPasses(), $filterEnabled))
100	52	);
101	52	$analyzer->registerScalarPasses(
102	52	array_map($instanciate, array_filter(self::getScalarPasses(), $filterEnabled))
103	52	);
104	52	$analyzer->bind();
105
106	52	return $analyzer;
107		}
108
109		/**
110		* @return array
111		*/
112	54	private static function getStatementPasses()
113		{
114		return [
115	54	AnalyzerPass\Statement\MagicMethodParameters::class,
116	54	AnalyzerPass\Statement\GotoUsage::class,
117	54	AnalyzerPass\Statement\GlobalUsage::class,
118	54	AnalyzerPass\Statement\HasMoreThanOneProperty::class,
119	54	AnalyzerPass\Statement\MissingBreakStatement::class,
120	54	AnalyzerPass\Statement\MissingVisibility::class,
121	54	AnalyzerPass\Statement\MethodCannotReturn::class,
122	54	AnalyzerPass\Statement\UnexpectedUseOfThis::class,
123	54	AnalyzerPass\Statement\TestAnnotation::class,
124	54	AnalyzerPass\Statement\MissingDocblock::class,
125	54	AnalyzerPass\Statement\OldConstructor::class,
126	54	AnalyzerPass\Statement\ConstantNaming::class,
127	54	AnalyzerPass\Statement\MissingBody::class,
128	54	AnalyzerPass\Statement\InlineHtmlUsage::class,
129	54	AnalyzerPass\Statement\AssignmentInCondition::class,
130	54	AnalyzerPass\Statement\StaticUsage::class,
131	54	AnalyzerPass\Statement\OptionalParamBeforeRequired::class,
132	54	AnalyzerPass\Statement\YodaCondition::class,
133	54	AnalyzerPass\Statement\ForCondition::class,
134	54	AnalyzerPass\Statement\PropertyDefinitionDefaultValue::class,
135	54	AnalyzerPass\Statement\ReturnAndYieldInOneMethod::class,
136	54	AnalyzerPass\Statement\ReturnVoid::class,
137	54	];
138		}
139
140		/**
141		* @return array
142		*/
143	54	private static function getExpressionPasses()
144		{
145		return [
146		// Another
147	54	AnalyzerPass\Expression\ErrorSuppression::class,
148	54	AnalyzerPass\Expression\MultipleUnaryOperators::class,
149	54	AnalyzerPass\Expression\StupidUnaryOperators::class,
150	54	AnalyzerPass\Expression\VariableVariableUsage::class,
151	54	AnalyzerPass\Expression\Casts::class,
152	54	AnalyzerPass\Expression\EvalUsage::class,
153	54	AnalyzerPass\Expression\FinalStaticUsage::class,
154	54	AnalyzerPass\Expression\CompareWithArray::class,
155	54	AnalyzerPass\Expression\DivisionFromZero::class,
156	54	AnalyzerPass\Expression\DivisionByOne::class,
157	54	AnalyzerPass\Expression\BacktickUsage::class,
158	54	AnalyzerPass\Expression\LogicInversion::class,
159	54	AnalyzerPass\Expression\ExitUsage::class,
160	54	AnalyzerPass\Expression\NestedTernary::class,
161	54	AnalyzerPass\Expression\AssignRefNew::class,
162		// Arrays
163	54	AnalyzerPass\Expression\ArrayShortDefinition::class,
164	54	AnalyzerPass\Expression\ArrayDuplicateKeys::class,
165	54	AnalyzerPass\Expression\ArrayIllegalOffsetType::class,
166		// Function call
167	54	AnalyzerPass\Expression\FunctionCall\AliasCheck::class,
168	54	AnalyzerPass\Expression\FunctionCall\DebugCode::class,
169	54	AnalyzerPass\Expression\FunctionCall\RandomApiMigration::class,
170	54	AnalyzerPass\Expression\FunctionCall\SleepUsage::class,
171	54	AnalyzerPass\Expression\FunctionCall\UseCast::class,
172	54	AnalyzerPass\Expression\FunctionCall\DeprecatedIniOptions::class,
173	54	AnalyzerPass\Expression\FunctionCall\RegularExpressions::class,
174	54	AnalyzerPass\Expression\FunctionCall\ArgumentUnpacking::class,
175	54	AnalyzerPass\Expression\FunctionCall\UnsafeUnserialize::class,
176	54	AnalyzerPass\Expression\FunctionCall\DeprecatedFunctions::class,
177	54	AnalyzerPass\Expression\FunctionCall\FunctionStringFormater::class,
178	54	];
179		}
180
181		/**
182		* @return array
183		*/
184	54	private static function getScalarPasses()
185		{
186		return [
187	54	AnalyzerPass\Scalar\CheckLNumberKind::class,
188	54	];
189		}
190		}
191

ovr / phpsa

Push — master ( 031f6e...a91da6 )

Factory::getPassesMetadata() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like