Benoth\StaticReflection\Reflection\ReflectionMethod

Complexity

Total Complexity

32

Size/Duplication

Total Lines	128
Duplicated Lines	5.47 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

0%

Importance

Changes	2
Bugs	1	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	isConstructor()	0	4	1
A	isDestructor()	0	4	1
D	getPrototype()	0	31	10
D	getParent()	7	47	19
A	setAccessible()	0	4	1

<?php

namespace Benoth\StaticReflection\Reflection;

class ReflectionMethod extends ReflectionFunctionAbstract
{
    use Parts\VisibilityTrait;
    use Parts\StaticTrait;
    use Parts\AbstractTrait;
    use Parts\FinalTrait;
    use Parts\DeclaringClassLikeTrait;

    /**
     * Checks if the method is a constructor.
     *
     * @return bool
     */
    public function isConstructor()
    {
        return $this->getName() === '__construct';
    }

    /**
     * Checks if the method is a destructor.
     *
     * @return bool
     */
    public function isDestructor()
    {
        return $this->getName() === '__destruct';
    }

    /**
     * Returns the methods prototype.
     *
     * @throws \ReflectionException If the method does not have a prototype.
     *
     * @return ReflectionMethod
     */
    public function getPrototype()
    {
        $parent     = $this->getDeclaringClass();
        $methodName = $this->getName();

        while (!is_null($parent)) {
            if ($parent instanceof ReflectionClass || $parent instanceof ReflectionInterface) {
                foreach ($parent->getSelfInterfaces() as $interface) {
                    if ($interface->hasMethod($methodName)) {
                        return $interface->getMethod($methodName);
                    }
                }
            }

            if (!$parent instanceof ReflectionClass) {
                $parent = null;
                continue;
            }

            $parent = $parent->getParentClass();
            if (is_null($parent)) {
                continue;
            }

            if ($parent->hasMethod($methodName) && $parent->getMethod($methodName)->isAbstract()) {
                return $parent->getMethod($methodName);
            }
        }

        throw new \ReflectionException('Method '.$this->getDeclaringClass()->getName().'::'.$this->getName().' does not have a prototype');
    }

    public function getParent()
    {
        $class = $this->getDeclaringClass();

        $methods = [];
        foreach ($class->getSelfMethods() as $methodName => $method) {
            if ($methodName === $this->getName()) {
                $methods[] = $method;
            }
        }

        if ($class instanceof ReflectionClass) {
            foreach ($class->getTraitsMethods() as $methodName => $method) {
                if ($methodName === $this->getName()) {

The strict comparison === seems to always evaluate to false as the types of $methodName (integer) and $this->getName() (string) can never be identical. Maybe you want to use a loose comparison == instead?

                    $methods[] = $method;
                }
            }
        }

        if (($class instanceof ReflectionClass || $class instanceof \ReflectionClass) && ($class->getParentClass() instanceof ReflectionClass || $class->getParentClass() instanceof \ReflectionClass)) {
            foreach ($class->getParentClass()->getMethods() as $methodName => $method) {
                if (is_int($methodName)) {
                    $methodName = $method->getName();
                }
                if ($methodName === $this->getName()) {
                    $methods[] = $method;
                }
            }
        }

        if ($class instanceof ReflectionClass || $class instanceof \ReflectionClass) {
            foreach ($class->getInterfaces() as $interfaceName => $interface) {

This code seems to be duplicated across your project.

                foreach ($interface->getMethods() as $methodName => $method) {
                    if ($methodName === $this->getName()) {
                        $methods[] = $method;
                    }
                }
            }
        }

        if (count($methods) >= 2) {
            // $methods[0] is the current method
            return $methods[1];
        }

        return;
    }

    /**
     * Sets a method to be accessible.
     *
     *
     * @param bool $accessible
     *
     * @throws \ReflectionException Always... Can't be implemented.
     */
    public function setAccessible($accessible)

The parameter $accessible is not used and could be removed.

    {
        throw new \ReflectionException('StaticReflection can\'t change a method accessibility');
    }
}