Roave\ApiCompare\Comparator\BackwardsCompatibility\FunctionBased\ParameterByReferenceChanged

Complexity

Total Complexity

7

Size/Duplication

Total Lines	52
Duplicated Lines	0 %

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	compare()	0	14	2
A	__construct()	0	3	1
A	referenceToString()	0	3	2
A	compareParameter()	0	19	2

<?php

declare(strict_types=1);

namespace Roave\ApiCompare\Comparator\BackwardsCompatibility\FunctionBased;

use Roave\ApiCompare\Change;
use Roave\ApiCompare\Changes;
use Roave\ApiCompare\Formatter\ReflectionFunctionAbstractName;
use Roave\BetterReflection\Reflection\ReflectionFunctionAbstract;
use Roave\BetterReflection\Reflection\ReflectionMethod;
use Roave\BetterReflection\Reflection\ReflectionParameter;

/**
 * A parameter passed by-value and a parameter passed by-reference are wildly different, so changing
 * the by-ref flag can lead to unexpected state mutations or lack thereof, and should therefore be
 * considered a BC break.
 */
final class ParameterByReferenceChanged implements FunctionBased
{
    /** @var ReflectionFunctionAbstractName */
    private $formatFunction;

    public function __construct()
    {
        $this->formatFunction = new ReflectionFunctionAbstractName();
    }

    public function compare(ReflectionFunctionAbstract $fromFunction, ReflectionFunctionAbstract $toFunction) : Changes
    {
        /** @var ReflectionParameter[] $fromParameters */
        $fromParameters = array_values($fromFunction->getParameters());
        /** @var ReflectionParameter[] $toParameters */
        $toParameters = array_values($toFunction->getParameters());

        $changes = Changes::new();

        foreach (array_intersect_key($fromParameters, $toParameters) as $parameterIndex => $commonParameter) {
            $changes = $changes->mergeWith($this->compareParameter($commonParameter, $toParameters[$parameterIndex]));
        }

        return $changes;
    }

    private function compareParameter(ReflectionParameter $fromParameter, ReflectionParameter $toParameter) : Changes
    {
        $fromByReference = $fromParameter->isPassedByReference();
        $toByReference   = $toParameter->isPassedByReference();

        if ($fromByReference === $toByReference) {
            return Changes::new();
        }

        return Changes::fromArray([
            Change::changed(
                sprintf(
                    'The parameter $%s of %s changed from %s to %s',
                    $fromParameter->getName(),
                    $this->formatFunction->__invoke($fromParameter->getDeclaringFunction()),
                    $this->referenceToString($fromByReference),
                    $this->referenceToString($toByReference)
                ),
                true
            ),
        ]);
    }

    private function referenceToString(bool $reference) : string
    {
        return $reference ? 'by-reference' : 'by-value';
    }
}