ClassChecker::processMethods() - Code Metrics - Inspection of "Ignore PHP5 into PHP4 constructor rename" - console-helpers/code-insight - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 951a34...0736c8 )

by Alexander

created 2017-02-03 08:57 UTC

ClassChecker::processMethods() C

↳ Parent: ClassChecker

Complexity

Conditions	8
Paths	13

Size

Total Lines	49
Code Lines	28

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	35
CRAP Score	8

Importance

Changes

Metric	Value
dl	0
loc	49
ccs	35
cts	35
cp	1
rs	6.1403
c	0
b	0
f	0
cc	8
eloc	28
nc	13
nop	0
crap	8

<?php
/**
 * This file is part of the Code-Insight library.
 * For the full copyright and license information, please view
 * the LICENSE file that was distributed with this source code.
 *
 * @copyright Alexander Obuhovich <[email protected]>
 * @link      https://github.com/console-helpers/code-insight
 */

namespace ConsoleHelpers\CodeInsight\BackwardsCompatibility\Checker;


use Aura\Sql\ExtendedPdoInterface;
use ConsoleHelpers\CodeInsight\KnowledgeBase\DataCollector\ClassDataCollector;

class ClassChecker extends AbstractChecker
{

	const CACHE_DURATION = 3600;

	const TYPE_CLASS_DELETED = 'class.deleted';
	const TYPE_CLASS_MADE_ABSTRACT = 'class.made_abstract';
	const TYPE_CLASS_MADE_FINAL = 'class.made_final';
	const TYPE_CLASS_CONSTANT_DELETED = 'class.constant.deleted';
	const TYPE_PROPERTY_DELETED = 'property.deleted';
	const TYPE_PROPERTY_SCOPE_REDUCED = 'property.scope_reduced';
	const TYPE_METHOD_DELETED = 'method.deleted';
	const TYPE_METHOD_MADE_ABSTRACT = 'method.made_abstract';
	const TYPE_METHOD_MADE_FINAL = 'method.made_final';
	const TYPE_METHOD_SCOPE_REDUCED = 'method.scope_reduced';
	const TYPE_METHOD_SIGNATURE_CHANGED = 'method.signature_changed';

	/**
	 * Source class data.
	 *
	 * @var array
	 */
	protected $sourceClassData = array();

	/**
	 * Target class data.
	 *
	 * @var array
	 */
	protected $targetClassData = array();

	/**
	 * Source property data.
	 *
	 * @var array
	 */
	protected $sourcePropertyData = array();

	/**
	 * Target property data.
	 *
	 * @var array
	 */
	protected $targetPropertyData = array();

	/**
	 * Source method data.
	 *
	 * @var array
	 */
	protected $sourceMethodData = array();

	/**
	 * Target method data.
	 *
	 * @var array
	 */
	protected $targetMethodData = array();

	/**
	 * Returns backwards compatibility checker name.
	 *
	 * @return string
	 */
	public function getName()
	{
		return 'class';
	}

	/**
	 * Collects backwards compatibility violations.
	 *
	 * @return void
	 */
	protected function doCheck()
	{
		$classes_sql = 'SELECT Name, Id, IsAbstract, IsFinal
						FROM Classes';
		$source_classes = $this->sourceDatabase->fetchAssoc($classes_sql);
		$target_classes = $this->targetDatabase->fetchAssoc($classes_sql);

		foreach ( $source_classes as $class_name => $source_class_data ) {
			if ( !isset($target_classes[$class_name]) ) {
				$this->addIncident(self::TYPE_CLASS_DELETED, $class_name);
				continue;
			}

			$this->sourceClassData = $source_class_data;
			$this->targetClassData = $target_classes[$class_name];

			if ( !$this->sourceClassData['IsAbstract'] && $this->targetClassData['IsAbstract'] ) {
				$this->addIncident(self::TYPE_CLASS_MADE_ABSTRACT, $class_name);
			}

			if ( !$this->sourceClassData['IsFinal'] && $this->targetClassData['IsFinal'] ) {
				$this->addIncident(self::TYPE_CLASS_MADE_FINAL, $class_name);
			}

			$this->processConstants();
			$this->processProperties();
			$this->processMethods();
		}
	}

	/**
	 * Checks constants.
	 *
	 * @return void
	 */
	protected function processConstants()
	{
		$class_name = $this->sourceClassData['Name'];

		$source_constants = $this->getConstantsRecursively($this->sourceDatabase, $this->sourceClassData['Id']);
		$target_constants = $this->getConstantsRecursively($this->targetDatabase, $this->targetClassData['Id']);

		foreach ( $source_constants as $source_constant_name => $source_constant_data ) {
			$full_constant_name = $class_name . '::' . $source_constant_name;

			// @codeCoverageIgnoreStart
			// Report incidents for processed (not inherited) constants only.
			if ( $source_constant_data['ClassId'] !== $this->sourceClassData['Id'] ) {
				continue;
			}
			// @codeCoverageIgnoreEnd

			if ( !isset($target_constants[$source_constant_name]) ) {
				$this->addIncident(self::TYPE_CLASS_CONSTANT_DELETED, $full_constant_name);
				continue;
			}
		}
	}

	/**
	 * Returns class constants.
	 *
	 * @param ExtendedPdoInterface $db       Database.
	 * @param integer              $class_id Class ID.
	 *
	 * @return array
	 */
	protected function getConstantsRecursively(ExtendedPdoInterface $db, $class_id)
	{
		$cache_key = $this->getCacheKey($db, 'class_constants[' . $class_id . ']');
		$cached_value = $this->cache->fetch($cache_key);

		if ( $cached_value === false ) {
			$sql = 'SELECT Name, ClassId
					FROM ClassConstants
					WHERE ClassId = :class_id';
			$cached_value = $db->fetchAssoc($sql, array('class_id' => $class_id));

			foreach ( $this->getClassRelations($db, $class_id) as $related_class_id => $related_class_name ) {
				foreach ( $this->getConstantsRecursively($db, $related_class_id) as $name => $data ) {
					// @codeCoverageIgnoreStart
					if ( !array_key_exists($name, $cached_value) ) {
						$cached_value[$name] = $data;
					}
					// @codeCoverageIgnoreEnd
				}
			}

			// TODO: Cache for longer period, when DB update will invalidate associated cache.
			$this->cache->save($cache_key, $cached_value, self::CACHE_DURATION);
		}

		return $cached_value;
	}

	/**
	 * Checks properties.
	 *
	 * @return void
	 */
	protected function processProperties()
	{
		$class_name = $this->sourceClassData['Name'];
		$source_properties = $this->getPropertiesRecursively(
			$this->sourceDatabase,
			$this->sourceClassData['Id'],
			$this->coveredScopes()
		);
		$target_properties = $this->getPropertiesRecursively($this->targetDatabase, $this->targetClassData['Id'], '');

		foreach ( $source_properties as $source_property_name => $source_property_data ) {
			$full_property_name = $class_name . '::$' . $source_property_name;

			// Report incidents for processed (not inherited) properties only.
			if ( $source_property_data['ClassId'] !== $this->sourceClassData['Id'] ) {
				continue;
			}

			if ( !isset($target_properties[$source_property_name]) ) {
				$this->addIncident(self::TYPE_PROPERTY_DELETED, $full_property_name);
				continue;
			}

			$this->sourcePropertyData = $source_property_data;
			$this->targetPropertyData = $target_properties[$source_property_name];

			$this->processProperty();
		}
	}

	/**
	 * Returns class properties.
	 *
	 * @param ExtendedPdoInterface $db       Database.
	 * @param integer              $class_id Class ID.
	 * @param string               $scopes   Scopes.
	 *
	 * @return array
	 */
	protected function getPropertiesRecursively(ExtendedPdoInterface $db, $class_id, $scopes)
	{
		$cache_key = $this->getCacheKey($db, 'class_properties[' . $class_id . ']_scopes[' . ($scopes ?: '*') . ']');
		$cached_value = $this->cache->fetch($cache_key);

		if ( $cached_value === false ) {
			$sql = 'SELECT Name, Scope, ClassId
					FROM ClassProperties
					WHERE ClassId = :class_id';

			if ( $scopes ) {
				$sql .= ' AND Scope IN (' . $scopes . ')';
			}

			$cached_value = $db->fetchAssoc($sql, array('class_id' => $class_id));

			foreach ( $this->getClassRelations($db, $class_id) as $related_class_id => $related_class_name ) {
				foreach ( $this->getPropertiesRecursively($db, $related_class_id, $scopes) as $name => $data ) {
					if ( !array_key_exists($name, $cached_value) ) {
						$cached_value[$name] = $data;
					}
				}
			}

			// TODO: Cache for longer period, when DB update will invalidate associated cache.
			$this->cache->save($cache_key, $cached_value, self::CACHE_DURATION);
		}

		return $cached_value;
	}

	/**
	 * Processes property.
	 *
	 * @return void
	 */
	protected function processProperty()
	{
		$class_name = $this->sourceClassData['Name'];
		$property_name = $this->sourcePropertyData['Name'];

		$full_property_name = $class_name . '::$' . $property_name;

		if ( $this->sourcePropertyData['Scope'] > $this->targetPropertyData['Scope'] ) {
			$this->addIncident(
				self::TYPE_PROPERTY_SCOPE_REDUCED,
				$full_property_name,
				$this->getScopeName($this->sourcePropertyData['Scope']),
				$this->getScopeName($this->targetPropertyData['Scope'])
			);
		}
	}

	/**
	 * Checks methods.
	 *
	 * @return void
	 */
	protected function processMethods()
	{
		$class_name = $this->sourceClassData['Name'];
		$source_methods = $this->getMethodsRecursively(
			$this->sourceDatabase,
			$this->sourceClassData['Id'],
			$this->coveredScopes()
		);
		$target_methods = $this->getMethodsRecursively($this->targetDatabase, $this->targetClassData['Id'], '');

		foreach ( $source_methods as $source_method_name => $source_method_data ) {
			$target_method_name = $source_method_name;
			$full_method_name = $class_name . '::' . $source_method_name;

			// Ignore PHP4 constructor rename into PHP5 constructor.
			if ( !isset($target_methods[$target_method_name]) && $target_method_name === $class_name ) {
				$target_method_name = '__construct';
			}

			// Ignore PHP5 constructor rename into PHP4 constructor.
			if ( !isset($target_methods[$target_method_name]) && $target_method_name === '__construct' ) {
				$target_method_name = $class_name;
			}

			// Report incidents for processed (not inherited) methods only.
			if ( $source_method_data['ClassId'] !== $this->sourceClassData['Id'] ) {
				continue;
			}

			if ( !isset($target_methods[$target_method_name]) ) {
				$this->addIncident(self::TYPE_METHOD_DELETED, $full_method_name);
				continue;
			}

			$this->sourceMethodData = $source_method_data;
			$this->sourceMethodData['ParameterSignature'] = $this->getMethodParameterSignature(
				$this->sourceDatabase,
				$this->sourceMethodData['Id']
			);

			$this->targetMethodData = $target_methods[$target_method_name];
			$this->targetMethodData['ParameterSignature'] = $this->getMethodParameterSignature(
				$this->targetDatabase,
				$this->targetMethodData['Id']
			);

			$this->processMethod();
		}
	}

	/**
	 * Returns class methods.
	 *
	 * @param ExtendedPdoInterface $db       Database.
	 * @param integer              $class_id Class ID.
	 * @param string               $scopes   Scopes.
	 *
	 * @return array
	 */
	protected function getMethodsRecursively(ExtendedPdoInterface $db, $class_id, $scopes)
	{
		$cache_key = $this->getCacheKey($db, 'class_methods[' . $class_id . ']_scopes[' . ($scopes ?: '*') . ']');
		$cached_value = $this->cache->fetch($cache_key);

		if ( $cached_value === false ) {
			$sql = 'SELECT Name, Id, Scope, IsAbstract, IsFinal, ClassId
					FROM ClassMethods
					WHERE ClassId = :class_id';

			if ( $scopes ) {
				$sql .= ' AND Scope IN (' . $scopes . ')';
			}

			$cached_value = $db->fetchAssoc($sql, array('class_id' => $class_id));

			foreach ( $this->getClassRelations($db, $class_id) as $related_class_id => $related_class_name ) {
				foreach ( $this->getMethodsRecursively($db, $related_class_id, $scopes) as $name => $data ) {
					if ( !array_key_exists($name, $cached_value) ) {
						$cached_value[$name] = $data;
					}
				}
			}

			// TODO: Cache for longer period, when DB update will invalidate associated cache.
			$this->cache->save($cache_key, $cached_value, self::CACHE_DURATION);
		}

		return $cached_value;
	}

	/**
	 * Calculates method parameter signature.
	 *
	 * @param ExtendedPdoInterface $db        Database.
	 * @param integer              $method_id Method ID.
	 *
	 * @return integer
	 */
	protected function getMethodParameterSignature(ExtendedPdoInterface $db, $method_id)
	{
		$sql = 'SELECT *
				FROM MethodParameters
				WHERE MethodId = :method_id
				ORDER BY Position ASC';
		$method_parameters = $db->fetchAll($sql, array('method_id' => $method_id));

		$hash_parts = array();

		foreach ( $method_parameters as $method_parameter_data ) {
			$hash_parts[] = $this->paramToString($method_parameter_data);
		}

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

	/**
	 * Processes method.
	 *
	 * @return void
	 */
	protected function processMethod()
	{
		$class_name = $this->sourceClassData['Name'];
		$method_name = $this->sourceMethodData['Name'];

		$full_method_name = $class_name . '::' . $method_name;

		if ( !$this->sourceMethodData['IsAbstract'] && $this->targetMethodData['IsAbstract'] ) {
			$this->addIncident(self::TYPE_METHOD_MADE_ABSTRACT, $full_method_name);
		}

		if ( !$this->sourceMethodData['IsFinal'] && $this->targetMethodData['IsFinal'] ) {
			$this->addIncident(self::TYPE_METHOD_MADE_FINAL, $full_method_name);
		}

		if ( $this->sourceMethodData['ParameterSignature'] !== $this->targetMethodData['ParameterSignature'] ) {
			$this->addIncident(
				self::TYPE_METHOD_SIGNATURE_CHANGED,
				$full_method_name,
				$this->sourceMethodData['ParameterSignature'],
				$this->targetMethodData['ParameterSignature']
			);
		}

		if ( $this->sourceMethodData['Scope'] > $this->targetMethodData['Scope'] ) {
			$this->addIncident(
				self::TYPE_METHOD_SCOPE_REDUCED,
				$full_method_name,
				$this->getScopeName($this->sourceMethodData['Scope']),
				$this->getScopeName($this->targetMethodData['Scope'])
			);
		}
	}

	/**
	 * Returns scope name.
	 *
	 * @param integer $scope Scope.
	 *
	 * @return string
	 */
	protected function getScopeName($scope)
	{
		$mapping = array(
			ClassDataCollector::SCOPE_PRIVATE => 'private',
			ClassDataCollector::SCOPE_PROTECTED => 'protected',
			ClassDataCollector::SCOPE_PUBLIC => 'public',
		);

		return $mapping[$scope];
	}

	/**
	 * Scopes covered by backwards compatibility checks.
	 *
	 * @return string
	 */
	protected function coveredScopes()
	{
		return ClassDataCollector::SCOPE_PUBLIC . ',' . ClassDataCollector::SCOPE_PROTECTED;
	}

	/**
	 * Returns class constants.
	 *
	 * @param ExtendedPdoInterface $db       Database.
	 * @param integer              $class_id Class ID.
	 *
	 * @return array
	 */
	protected function getClassRelations(ExtendedPdoInterface $db, $class_id)
	{
		$cache_key = $this->getCacheKey($db, 'class_relations[' . $class_id . ']');
		$cached_value = $this->cache->fetch($cache_key);

		if ( $cached_value === false ) {
			$sql = 'SELECT RelatedClassId, RelatedClass
					FROM ClassRelations
					WHERE ClassId = :class_id AND RelatedClassId <> 0';
			$cached_value = $db->fetchPairs($sql, array('class_id' => $class_id));

			// TODO: Cache for longer period, when DB update will invalidate associated cache.
			$this->cache->save($cache_key, $cached_value, self::CACHE_DURATION);
		}

		return $cached_value;
	}

}


1		<?php
2		/**
3		* This file is part of the Code-Insight library.
4		* For the full copyright and license information, please view
5		* the LICENSE file that was distributed with this source code.
6		*
7		* @copyright Alexander Obuhovich <[email protected]>
8		* @link https://github.com/console-helpers/code-insight
9		*/
10
11		namespace ConsoleHelpers\CodeInsight\BackwardsCompatibility\Checker;
12
13
14		use Aura\Sql\ExtendedPdoInterface;
15		use ConsoleHelpers\CodeInsight\KnowledgeBase\DataCollector\ClassDataCollector;
16
17		class ClassChecker extends AbstractChecker
18		{
19
20		const CACHE_DURATION = 3600;
21
22		const TYPE_CLASS_DELETED = 'class.deleted';
23		const TYPE_CLASS_MADE_ABSTRACT = 'class.made_abstract';
24		const TYPE_CLASS_MADE_FINAL = 'class.made_final';
25		const TYPE_CLASS_CONSTANT_DELETED = 'class.constant.deleted';
26		const TYPE_PROPERTY_DELETED = 'property.deleted';
27		const TYPE_PROPERTY_SCOPE_REDUCED = 'property.scope_reduced';
28		const TYPE_METHOD_DELETED = 'method.deleted';
29		const TYPE_METHOD_MADE_ABSTRACT = 'method.made_abstract';
30		const TYPE_METHOD_MADE_FINAL = 'method.made_final';
31		const TYPE_METHOD_SCOPE_REDUCED = 'method.scope_reduced';
32		const TYPE_METHOD_SIGNATURE_CHANGED = 'method.signature_changed';
33
34		/**
35		* Source class data.
36		*
37		* @var array
38		*/
39		protected $sourceClassData = array();
40
41		/**
42		* Target class data.
43		*
44		* @var array
45		*/
46		protected $targetClassData = array();
47
48		/**
49		* Source property data.
50		*
51		* @var array
52		*/
53		protected $sourcePropertyData = array();
54
55		/**
56		* Target property data.
57		*
58		* @var array
59		*/
60		protected $targetPropertyData = array();
61
62		/**
63		* Source method data.
64		*
65		* @var array
66		*/
67		protected $sourceMethodData = array();
68
69		/**
70		* Target method data.
71		*
72		* @var array
73		*/
74		protected $targetMethodData = array();
75
76		/**
77		* Returns backwards compatibility checker name.
78		*
79		* @return string
80		*/
81	1	public function getName()
82		{
83	1	return 'class';
84		}
85
86		/**
87		* Collects backwards compatibility violations.
88		*
89		* @return void
90		*/
91	4	protected function doCheck()
92		{
93		$classes_sql = 'SELECT Name, Id, IsAbstract, IsFinal
94	4	FROM Classes';
95	4	$source_classes = $this->sourceDatabase->fetchAssoc($classes_sql);
96	4	$target_classes = $this->targetDatabase->fetchAssoc($classes_sql);
97
98	4	foreach ( $source_classes as $class_name => $source_class_data ) {
99	4	if ( !isset($target_classes[$class_name]) ) {
100	2	$this->addIncident(self::TYPE_CLASS_DELETED, $class_name);
101	2	continue;
102		}
103
104	4	$this->sourceClassData = $source_class_data;
105	4	$this->targetClassData = $target_classes[$class_name];
106
107	4	if ( !$this->sourceClassData['IsAbstract'] && $this->targetClassData['IsAbstract'] ) {
108	2	$this->addIncident(self::TYPE_CLASS_MADE_ABSTRACT, $class_name);
109	2	}
110
111	4	if ( !$this->sourceClassData['IsFinal'] && $this->targetClassData['IsFinal'] ) {
112	2	$this->addIncident(self::TYPE_CLASS_MADE_FINAL, $class_name);
113	2	}
114
115	4	$this->processConstants();
116	4	$this->processProperties();
117	4	$this->processMethods();
118	4	}
119	4	}
120
121		/**
122		* Checks constants.
123		*
124		* @return void
125		*/
126	4	protected function processConstants()
127		{
128	4	$class_name = $this->sourceClassData['Name'];
129
130	4	$source_constants = $this->getConstantsRecursively($this->sourceDatabase, $this->sourceClassData['Id']);
131	4	$target_constants = $this->getConstantsRecursively($this->targetDatabase, $this->targetClassData['Id']);
132
133	4	foreach ( $source_constants as $source_constant_name => $source_constant_data ) {
134	4	$full_constant_name = $class_name . '::' . $source_constant_name;
135
136		// @codeCoverageIgnoreStart
137		// Report incidents for processed (not inherited) constants only.
138		if ( $source_constant_data['ClassId'] !== $this->sourceClassData['Id'] ) {
139		continue;
140		}
141		// @codeCoverageIgnoreEnd
142
143	4	if ( !isset($target_constants[$source_constant_name]) ) {
144	2	$this->addIncident(self::TYPE_CLASS_CONSTANT_DELETED, $full_constant_name);
145	2	continue;
146		}
147	4	}
148	4	}
149
150		/**
151		* Returns class constants.
152		*
153		* @param ExtendedPdoInterface $db Database.
154		* @param integer $class_id Class ID.
155		*
156		* @return array
157		*/
158	4	protected function getConstantsRecursively(ExtendedPdoInterface $db, $class_id)
159		{
160	4	$cache_key = $this->getCacheKey($db, 'class_constants[' . $class_id . ']');
161	4	$cached_value = $this->cache->fetch($cache_key);
162
163	4	if ( $cached_value === false ) {
164		$sql = 'SELECT Name, ClassId
165		FROM ClassConstants
166	4	WHERE ClassId = :class_id';
167	4	$cached_value = $db->fetchAssoc($sql, array('class_id' => $class_id));
168
169	4	foreach ( $this->getClassRelations($db, $class_id) as $related_class_id => $related_class_name ) {
170	4	foreach ( $this->getConstantsRecursively($db, $related_class_id) as $name => $data ) {
171		// @codeCoverageIgnoreStart
172		if ( !array_key_exists($name, $cached_value) ) {
173		$cached_value[$name] = $data;
174		}
175		// @codeCoverageIgnoreEnd
176	4	}
177	4	}
178
179		// TODO: Cache for longer period, when DB update will invalidate associated cache.
180	4	$this->cache->save($cache_key, $cached_value, self::CACHE_DURATION);
181	4	}
182
183	4	return $cached_value;
184		}
185
186		/**
187		* Checks properties.
188		*
189		* @return void
190		*/
191	4	protected function processProperties()
192		{
193	4	$class_name = $this->sourceClassData['Name'];
194	4	$source_properties = $this->getPropertiesRecursively(
195	4	$this->sourceDatabase,
196	4	$this->sourceClassData['Id'],
197	4	$this->coveredScopes()
198	4	);
199	4	$target_properties = $this->getPropertiesRecursively($this->targetDatabase, $this->targetClassData['Id'], '');
200
201	4	foreach ( $source_properties as $source_property_name => $source_property_data ) {
202	4	$full_property_name = $class_name . '::$' . $source_property_name;
203
204		// Report incidents for processed (not inherited) properties only.
205	4	if ( $source_property_data['ClassId'] !== $this->sourceClassData['Id'] ) {
206	4	continue;
207		}
208
209	4	if ( !isset($target_properties[$source_property_name]) ) {
210	2	$this->addIncident(self::TYPE_PROPERTY_DELETED, $full_property_name);
211	2	continue;
212		}
213
214	4	$this->sourcePropertyData = $source_property_data;
215	4	$this->targetPropertyData = $target_properties[$source_property_name];
216
217	4	$this->processProperty();
218	4	}
219	4	}
220
221		/**
222		* Returns class properties.
223		*
224		* @param ExtendedPdoInterface $db Database.
225		* @param integer $class_id Class ID.
226		* @param string $scopes Scopes.
227		*
228		* @return array
229		*/
230	4	protected function getPropertiesRecursively(ExtendedPdoInterface $db, $class_id, $scopes)
231		{
232	4	$cache_key = $this->getCacheKey($db, 'class_properties[' . $class_id . ']_scopes[' . ($scopes ?: '*') . ']');
233	4	$cached_value = $this->cache->fetch($cache_key);
234
235	4	if ( $cached_value === false ) {
236		$sql = 'SELECT Name, Scope, ClassId
237		FROM ClassProperties
238	4	WHERE ClassId = :class_id';
239
240	4	if ( $scopes ) {
241	4	$sql .= ' AND Scope IN (' . $scopes . ')';
242	4	}
243
244	4	$cached_value = $db->fetchAssoc($sql, array('class_id' => $class_id));
245
246	4	foreach ( $this->getClassRelations($db, $class_id) as $related_class_id => $related_class_name ) {
247	4	foreach ( $this->getPropertiesRecursively($db, $related_class_id, $scopes) as $name => $data ) {
248	4	if ( !array_key_exists($name, $cached_value) ) {
249	4	$cached_value[$name] = $data;
250	4	}
251	4	}
252	4	}
253
254		// TODO: Cache for longer period, when DB update will invalidate associated cache.
255	4	$this->cache->save($cache_key, $cached_value, self::CACHE_DURATION);
256	4	}
257
258	4	return $cached_value;
259		}
260
261		/**
262		* Processes property.
263		*
264		* @return void
265		*/
266	4	protected function processProperty()
267		{
268	4	$class_name = $this->sourceClassData['Name'];
269	4	$property_name = $this->sourcePropertyData['Name'];
270
271	4	$full_property_name = $class_name . '::$' . $property_name;
272
273	4	if ( $this->sourcePropertyData['Scope'] > $this->targetPropertyData['Scope'] ) {
274	2	$this->addIncident(
275	2	self::TYPE_PROPERTY_SCOPE_REDUCED,
276	2	$full_property_name,
277	2	$this->getScopeName($this->sourcePropertyData['Scope']),
278	2	$this->getScopeName($this->targetPropertyData['Scope'])
279	2	);
280	2	}
281	4	}
282
283		/**
284		* Checks methods.
285		*
286		* @return void
287		*/
288	4	protected function processMethods()
289		{
290	4	$class_name = $this->sourceClassData['Name'];
291	4	$source_methods = $this->getMethodsRecursively(
292	4	$this->sourceDatabase,
293	4	$this->sourceClassData['Id'],
294	4	$this->coveredScopes()
295	4	);
296	4	$target_methods = $this->getMethodsRecursively($this->targetDatabase, $this->targetClassData['Id'], '');
297
298	4	foreach ( $source_methods as $source_method_name => $source_method_data ) {
299	4	$target_method_name = $source_method_name;
300	4	$full_method_name = $class_name . '::' . $source_method_name;
301
302		// Ignore PHP4 constructor rename into PHP5 constructor.
303	4	if ( !isset($target_methods[$target_method_name]) && $target_method_name === $class_name ) {
304	2	$target_method_name = '__construct';
305	2	}
306
307		// Ignore PHP5 constructor rename into PHP4 constructor.
308	4	if ( !isset($target_methods[$target_method_name]) && $target_method_name === '__construct' ) {
309	2	$target_method_name = $class_name;
310	2	}
311
312		// Report incidents for processed (not inherited) methods only.
313	4	if ( $source_method_data['ClassId'] !== $this->sourceClassData['Id'] ) {
314	4	continue;
315		}
316
317	4	if ( !isset($target_methods[$target_method_name]) ) {
318	2	$this->addIncident(self::TYPE_METHOD_DELETED, $full_method_name);
319	2	continue;
320		}
321
322	4	$this->sourceMethodData = $source_method_data;
323	4	$this->sourceMethodData['ParameterSignature'] = $this->getMethodParameterSignature(
324	4	$this->sourceDatabase,
325	4	$this->sourceMethodData['Id']
326	4	);
327
328	4	$this->targetMethodData = $target_methods[$target_method_name];
329	4	$this->targetMethodData['ParameterSignature'] = $this->getMethodParameterSignature(
330	4	$this->targetDatabase,
331	4	$this->targetMethodData['Id']
332	4	);
333
334	4	$this->processMethod();
335	4	}
336	4	}
337
338		/**
339		* Returns class methods.
340		*
341		* @param ExtendedPdoInterface $db Database.
342		* @param integer $class_id Class ID.
343		* @param string $scopes Scopes.
344		*
345		* @return array
346		*/
347	4	protected function getMethodsRecursively(ExtendedPdoInterface $db, $class_id, $scopes)
348		{
349	4	$cache_key = $this->getCacheKey($db, 'class_methods[' . $class_id . ']_scopes[' . ($scopes ?: '*') . ']');
350	4	$cached_value = $this->cache->fetch($cache_key);
351
352	4	if ( $cached_value === false ) {
353		$sql = 'SELECT Name, Id, Scope, IsAbstract, IsFinal, ClassId
354		FROM ClassMethods
355	4	WHERE ClassId = :class_id';
356
357	4	if ( $scopes ) {
358	4	$sql .= ' AND Scope IN (' . $scopes . ')';
359	4	}
360
361	4	$cached_value = $db->fetchAssoc($sql, array('class_id' => $class_id));
362
363	4	foreach ( $this->getClassRelations($db, $class_id) as $related_class_id => $related_class_name ) {
364	4	foreach ( $this->getMethodsRecursively($db, $related_class_id, $scopes) as $name => $data ) {
365	4	if ( !array_key_exists($name, $cached_value) ) {
366	4	$cached_value[$name] = $data;
367	4	}
368	4	}
369	4	}
370
371		// TODO: Cache for longer period, when DB update will invalidate associated cache.
372	4	$this->cache->save($cache_key, $cached_value, self::CACHE_DURATION);
373	4	}
374
375	4	return $cached_value;
376		}
377
378		/**
379		* Calculates method parameter signature.
380		*
381		* @param ExtendedPdoInterface $db Database.
382		* @param integer $method_id Method ID.
383		*
384		* @return integer
385		*/
386	4	protected function getMethodParameterSignature(ExtendedPdoInterface $db, $method_id)
387		{
388		$sql = 'SELECT *
389		FROM MethodParameters
390		WHERE MethodId = :method_id
391	4	ORDER BY Position ASC';
392	4	$method_parameters = $db->fetchAll($sql, array('method_id' => $method_id));
393
394	4	$hash_parts = array();
395
396	4	foreach ( $method_parameters as $method_parameter_data ) {
397	4	$hash_parts[] = $this->paramToString($method_parameter_data);
398	4	}
399
400	4	return implode(', ', $hash_parts);
401		}
402
403		/**
404		* Processes method.
405		*
406		* @return void
407		*/
408	4	protected function processMethod()
409		{
410	4	$class_name = $this->sourceClassData['Name'];
411	4	$method_name = $this->sourceMethodData['Name'];
412
413	4	$full_method_name = $class_name . '::' . $method_name;
414
415	4	if ( !$this->sourceMethodData['IsAbstract'] && $this->targetMethodData['IsAbstract'] ) {
416	2	$this->addIncident(self::TYPE_METHOD_MADE_ABSTRACT, $full_method_name);
417	2	}
418
419	4	if ( !$this->sourceMethodData['IsFinal'] && $this->targetMethodData['IsFinal'] ) {
420	2	$this->addIncident(self::TYPE_METHOD_MADE_FINAL, $full_method_name);
421	2	}
422
423	4	if ( $this->sourceMethodData['ParameterSignature'] !== $this->targetMethodData['ParameterSignature'] ) {
424	2	$this->addIncident(
425	2	self::TYPE_METHOD_SIGNATURE_CHANGED,
426	2	$full_method_name,
427	2	$this->sourceMethodData['ParameterSignature'],
428	2	$this->targetMethodData['ParameterSignature']
429	2	);
430	2	}
431
432	4	if ( $this->sourceMethodData['Scope'] > $this->targetMethodData['Scope'] ) {
433	2	$this->addIncident(
434	2	self::TYPE_METHOD_SCOPE_REDUCED,
435	2	$full_method_name,
436	2	$this->getScopeName($this->sourceMethodData['Scope']),
437	2	$this->getScopeName($this->targetMethodData['Scope'])
438	2	);
439	2	}
440	4	}
441
442		/**
443		* Returns scope name.
444		*
445		* @param integer $scope Scope.
446		*
447		* @return string
448		*/
449	2	protected function getScopeName($scope)
450		{
451		$mapping = array(
452	2	ClassDataCollector::SCOPE_PRIVATE => 'private',
453	2	ClassDataCollector::SCOPE_PROTECTED => 'protected',
454	2	ClassDataCollector::SCOPE_PUBLIC => 'public',
455	2	);
456
457	2	return $mapping[$scope];
458		}
459
460		/**
461		* Scopes covered by backwards compatibility checks.
462		*
463		* @return string
464		*/
465	4	protected function coveredScopes()
466		{
467	4	return ClassDataCollector::SCOPE_PUBLIC . ',' . ClassDataCollector::SCOPE_PROTECTED;
468		}
469
470		/**
471		* Returns class constants.
472		*
473		* @param ExtendedPdoInterface $db Database.
474		* @param integer $class_id Class ID.
475		*
476		* @return array
477		*/
478	4	protected function getClassRelations(ExtendedPdoInterface $db, $class_id)
479		{
480	4	$cache_key = $this->getCacheKey($db, 'class_relations[' . $class_id . ']');
481	4	$cached_value = $this->cache->fetch($cache_key);
482
483	4	if ( $cached_value === false ) {
484		$sql = 'SELECT RelatedClassId, RelatedClass
485		FROM ClassRelations
486	4	WHERE ClassId = :class_id AND RelatedClassId <> 0';
487	4	$cached_value = $db->fetchPairs($sql, array('class_id' => $class_id));
488
489		// TODO: Cache for longer period, when DB update will invalidate associated cache.
490	4	$this->cache->save($cache_key, $cached_value, self::CACHE_DURATION);
491	4	}
492
493	4	return $cached_value;
494		}
495
496		}
497

console-helpers / code-insight

Push — master ( 951a34...0736c8 )

ClassChecker::processMethods() C

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like