Go\ParserReflection\ReflectionMethod

Complexity

Total Complexity

48

Size/Duplication

Total Lines	318
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	10

Test Coverage

Coverage

97.32%

Importance

Changes

0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	14	2
A	getNode()	0	4	1
A	__debugInfo()	0	7	1
C	__toString()	0	46	15
A	getClosure()	0	6	1
A	getDeclaringClass()	0	4	1
B	getModifiers()	0	24	7
A	getPrototype()	0	14	3
A	invoke()	0	6	1
A	invokeArgs()	0	6	1
A	isAbstract()	0	4	2
A	isConstructor()	0	4	1
A	isDestructor()	0	4	1
A	isFinal()	0	4	1
A	isPrivate()	0	4	1
A	isProtected()	0	4	1
A	isPublic()	0	4	1
A	isStatic()	0	4	1
A	setAccessible()	0	6	1
A	collectFromClassNode()	0	20	3
A	__initialize()	0	4	1
A	getClassMethodNode()	0	4	1

<?php
declare(strict_types=1);
/**
 * Parser Reflection API
 *
 * @copyright Copyright 2015, Lisachenko Alexander <lisachenko.it@gmail.com>
 *
 * This source file is subject to the license that is bundled
 * with this source code in the file LICENSE.
 */

namespace Go\ParserReflection;

use Go\ParserReflection\Traits\InternalPropertiesEmulationTrait;
use Go\ParserReflection\Traits\ReflectionFunctionLikeTrait;
use PhpParser\Node\Stmt\ClassLike;
use PhpParser\Node\Stmt\ClassMethod;
use Reflection;
use ReflectionMethod as BaseReflectionMethod;

/**
 * AST-based reflection for the method in a class
 */
class ReflectionMethod extends BaseReflectionMethod
{
    use InternalPropertiesEmulationTrait;
    use ReflectionFunctionLikeTrait;

    /**
     * Name of the class
     *
     * @var string
     */
    private $className;

    /**
     * Optional declaring class reference
     *
     * @var ReflectionClass
     */
    private $declaringClass;

    /**
     * Initializes reflection instance for the method node
     *
     * @param string           $className       Name of the class
     * @param string           $methodName      Name of the method
     * @param ?ClassMethod     $classMethodNode AST-node for method

The doc-type ?ClassMethod could not be parsed: Unknown type name "?ClassMethod" at position 0. (view supported doc-types)

     * @param ?ReflectionClass $declaringClass  Optional declaring class

The doc-type ?ReflectionClass could not be parsed: Unknown type name "?ReflectionClass" at position 0. (view supported doc-types)

     */
    public function __construct(
        $className,
        $methodName,
        ClassMethod $classMethodNode = null,
        ReflectionClass $declaringClass = null
    ) {
        //for some reason, ReflectionMethod->getNamespaceName in php always returns '', so we shouldn't use it too
        $this->className        = ltrim($className, '\\');
        $this->declaringClass   = $declaringClass;
        $this->functionLikeNode = $classMethodNode ?: ReflectionEngine::parseClassMethod($className, $methodName);

        // Let's unset original read-only properties to have a control over them via __get
        unset($this->name, $this->class);
    }

    /**
     * Returns an AST-node for method
     */
    public function getNode(): ClassMethod
    {
        return $this->functionLikeNode;
    }

    /**
     * Emulating original behaviour of reflection
     */
    public function __debugInfo(): array
    {
        return [
            'name'  => $this->getClassMethodNode()->name->toString(),
            'class' => $this->className
        ];
    }

    /**
     * Returns the string representation of the Reflection method object.
     *
     * @link http://php.net/manual/en/reflectionmethod.tostring.php
     *
     * @return string
     */
    public function __toString()
    {
        // Internally $this->getReturnType() !== null is the same as $this->hasReturnType()
        $returnType       = $this->getReturnType();
        $hasReturnType    = $returnType !== null;
        $paramsNeeded     = $hasReturnType || $this->getNumberOfParameters() > 0;
        $paramFormat      = $paramsNeeded ? "\n\n  - Parameters [%d] {%s\n  }" : '';
        $returnFormat     = $hasReturnType ? "\n  - Return [ %s ]" : '';
        $methodParameters = $this->getParameters();
        try {
            $prototype = $this->getPrototype();
        } catch (\ReflectionException $e) {
            $prototype = null;
        }
        $prototypeClass = $prototype ? $prototype->getDeclaringClass()->name : '';

        $paramString = '';
        $indentation = str_repeat(' ', 4);
        foreach ($methodParameters as $methodParameter) {
            $paramString .= "\n{$indentation}" . $methodParameter;
        }

        return sprintf(
            "%sMethod [ <user%s%s%s>%s%s%s %s method %s ] {\n  @@ %s %d - %d{$paramFormat}{$returnFormat}\n}\n",
            $this->getDocComment() ? $this->getDocComment() . "\n" : '',
            $prototype ? ", overwrites {$prototypeClass}, prototype {$prototypeClass}" : '',
            $this->isConstructor() ? ', ctor' : '',
            $this->isDestructor() ? ', dtor' : '',
            $this->isFinal() ? ' final' : '',
            $this->isStatic() ? ' static' : '',
            $this->isAbstract() ? ' abstract' : '',
            implode(
                ' ',
                Reflection::getModifierNames(
                    $this->getModifiers() & (self::IS_PUBLIC | self::IS_PROTECTED | self::IS_PRIVATE)
                )
            ),
            $this->getName(),
            $this->getFileName(),
            $this->getStartLine(),
            $this->getEndLine(),
            count($methodParameters),
            $paramString,
            $returnType ? ReflectionType::convertToDisplayType($returnType) : ''
        );
    }

    /**
     * {@inheritDoc}
     */
    public function getClosure($object = null)
    {
        $this->initializeInternalReflection();

        return parent::getClosure($object);
    }

    /**
     * {@inheritDoc}
     */
    public function getDeclaringClass()
    {
        return $this->declaringClass ?? new ReflectionClass($this->className);
    }

    /**
     * {@inheritDoc}
     */
    public function getModifiers()
    {
        $modifiers = 0;
        if ($this->isPublic()) {
            $modifiers += self::IS_PUBLIC;
        }
        if ($this->isProtected()) {
            $modifiers += self::IS_PROTECTED;
        }
        if ($this->isPrivate()) {
            $modifiers += self::IS_PRIVATE;
        }
        if ($this->isAbstract()) {
            $modifiers += self::IS_ABSTRACT;
        }
        if ($this->isFinal()) {
            $modifiers += self::IS_FINAL;
        }
        if ($this->isStatic()) {
            $modifiers += self::IS_STATIC;
        }

        return $modifiers;
    }

    /**
     * {@inheritDoc}
     */
    public function getPrototype()
    {
        $parent = $this->getDeclaringClass()->getParentClass();
        if (!$parent) {
            throw new ReflectionException("No prototype");
        }

        $prototypeMethod = $parent->getMethod($this->getName());
        if (!$prototypeMethod) {
            throw new ReflectionException("No prototype");
        }

        return $prototypeMethod;
    }

    /**
     * {@inheritDoc}
     */
    public function invoke($object, $args = null)
    {
        $this->initializeInternalReflection();

        return parent::invoke(...func_get_args());
    }

    /**
     * {@inheritDoc}
     */
    public function invokeArgs($object, array $args)
    {
        $this->initializeInternalReflection();

        return parent::invokeArgs($object, $args);
    }

    /**
     * {@inheritDoc}
     */
    public function isAbstract()
    {
        return $this->getDeclaringClass()->isInterface() || $this->getClassMethodNode()->isAbstract();
    }

    /**
     * {@inheritDoc}
     */
    public function isConstructor()
    {
        return $this->getClassMethodNode()->name->toLowerString() === '__construct';
    }

    /**
     * {@inheritDoc}
     */
    public function isDestructor()
    {
        return $this->getClassMethodNode()->name->toLowerString() === '__destruct';
    }

    /**
     * {@inheritDoc}
     */
    public function isFinal()
    {
        return $this->getClassMethodNode()->isFinal();
    }

    /**
     * {@inheritDoc}
     */
    public function isPrivate()
    {
        return $this->getClassMethodNode()->isPrivate();
    }

    /**
     * {@inheritDoc}
     */
    public function isProtected()
    {
        return $this->getClassMethodNode()->isProtected();
    }

    /**
     * {@inheritDoc}
     */
    public function isPublic()
    {
        return $this->getClassMethodNode()->isPublic();
    }

    /**
     * {@inheritDoc}
     */
    public function isStatic()
    {
        return $this->getClassMethodNode()->isStatic();
    }

    /**
     * {@inheritDoc}
     */
    public function setAccessible($accessible)
    {
        $this->initializeInternalReflection();

        parent::setAccessible($accessible);
    }

    /**
     * Parses methods from the concrete class node
     *
     * @param ClassLike $classLikeNode Class-like node
     * @param ReflectionClass $reflectionClass Reflection of the class
     *
     * @return ReflectionMethod[]
     */
    public static function collectFromClassNode(ClassLike $classLikeNode, ReflectionClass $reflectionClass): array
    {
        $methods = [];

        foreach ($classLikeNode->stmts as $classLevelNode) {
            if ($classLevelNode instanceof ClassMethod) {
                $classLevelNode->setAttribute('fileName', $classLikeNode->getAttribute('fileName'));

                $methodName = $classLevelNode->name->toString();
                $methods[$methodName] = new ReflectionMethod(
                    $reflectionClass->name,
                    $methodName,
                    $classLevelNode,
                    $reflectionClass
                );
            }
        }

        return $methods;
    }

    /**
     * Implementation of internal reflection initialization
     */
    protected function __initialize(): void
    {
        parent::__construct($this->className, $this->getName());
    }

    /**
     * Returns ClassMethod node to prevent all possible type checks with instanceof
     */
    private function getClassMethodNode(): ClassMethod
    {
        return $this->functionLikeNode;
    }
}