PHPSemVerChecker\Comparator\Signature

Complexity

Total Complexity

19

Size/Duplication

Total Lines	90
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	analyze()	0	20	1
A	detectFunctionNameChanges()	0	15	3
D	detectParameterChanges()	0	49	15

<?php

namespace PHPSemVerChecker\Comparator;

use PhpParser\Node\FunctionLike;

class Signature
{

	public static function analyze(FunctionLike $functionA, FunctionLike $functionB)
	{
		$changes = [
			'function_renamed' => false,
			'function_renamed_case_only' => false,
			'parameter_added' => false,
			'parameter_removed' => false,
			'parameter_renamed' => false,
			'parameter_typing_added' => false,
			'parameter_typing_removed' => false,
			'parameter_default_added' => false,
			'parameter_default_removed' => false,
			'parameter_default_value_changed' => false,
		];

		$changes = self::detectFunctionNameChanges($changes, $functionA, $functionB);
		$changes = self::detectParameterChanges($changes, $functionA, $functionB);

		return $changes;
	}

	private static function detectFunctionNameChanges($changes, FunctionLike $functionA, FunctionLike $functionB)
	{
		if ($functionA->name != $functionB->name) {

Accessing name on the interface PhpParser\Node\FunctionLike suggest that you code against a concrete implementation. How about adding an instanceof check?

			if (strtolower($functionA->name) == strtolower($functionB->name)) {

Accessing name on the interface PhpParser\Node\FunctionLike suggest that you code against a concrete implementation. How about adding an instanceof check?

				$changes['function_renamed_case_only'] = true;
			} else {
				$changes['function_renamed'] = true;
			}

			return $changes;
		}

		return $changes;
	}

	private static function detectParameterChanges($changes, FunctionLike $functionA, FunctionLike $functionB)
	{
		$parametersA = $functionA->getParams();
		$parametersB = $functionB->getParams();

		$lengthA = count($parametersA);
		$lengthB = count($parametersB);

		// TODO(tom@tomrochette.com): This is only true if newer params do not have defaults
		if ($lengthA < $lengthB) {
			$changes['parameter_added'] = true;
		} elseif ($lengthA > $lengthB) {
			$changes['parameter_removed'] = true;
		}

		$iterations = min($lengthA, $lengthB);
		for ($i = 0; $i < $iterations; ++$i) {
			// Name checking
			if ($parametersA[$i]->name !== $parametersB[$i]->name) {
				$changes['parameter_renamed'] = true;
			}

			// Type checking
			if (Type::get($parametersA[$i]->type) !== Type::get($parametersB[$i]->type)) {

It seems like $parametersA[$i]->type can also be of type object<PhpParser\Node\NullableType>; however, PHPSemVerChecker\Comparator\Type::get() does only seem to accept object<PhpParser\Node\Name>|string|null, maybe add an additional type check?

It seems like $parametersB[$i]->type can also be of type object<PhpParser\Node\NullableType>; however, PHPSemVerChecker\Comparator\Type::get() does only seem to accept object<PhpParser\Node\Name>|string|null, maybe add an additional type check?

//				if ($paramsA[$i]->default !== null && $paramsB[$i]->default !== null) {

59% of this comment could be valid code. Did you maybe forget this after debugging?

//					$changes['parameter_default_value_changed'] = true;
				if ($parametersA[$i]->type !== null) {
					$changes['parameter_typing_removed'] = true;
				}
				if ($parametersB[$i]->type !== null) {
					$changes['parameter_typing_added'] = true;
				}
			}

			// Default checking
			if ($parametersA[$i]->default === null && $parametersB[$i]->default === null) {

This if statement is empty and can be removed.

				// Do nothing
			} elseif ($parametersA[$i]->default !== null && $parametersB[$i]->default === null) {
				$changes['parameter_default_removed'] = true;
			} elseif ($parametersA[$i]->default === null && $parametersB[$i]->default !== null) {
				$changes['parameter_default_added'] = true;
				// TODO(tom@tomrochette.com): Not all nodes have a value property
			} elseif (!Node::isEqual($parametersA[$i]->default, $parametersB[$i]->default)) {

It seems like $parametersA[$i]->default can be null; however, isEqual() does not accept null, maybe add an additional type check?

It seems like $parametersB[$i]->default can be null; however, isEqual() does not accept null, maybe add an additional type check?

				$changes['parameter_default_value_changed'] = true;
			}
		}

		return $changes;
	}
}