vendor/zendframework/zend-server/src/Reflection/ReflectionMethod.php

   1 <?php
   2 /**
   3  * @see       https://github.com/zendframework/zend-server for the canonical source repository
   4  * @copyright Copyright (c) 2005-2018 Zend Technologies USA Inc. (https://www.zend.com)
   5  * @license   https://github.com/zendframework/zend-server/blob/master/LICENSE.md New BSD License
   6  */
   7
   8 namespace Zend\Server\Reflection;
   9
  10 /**
  11  * Method Reflection
  12  */
  13 class ReflectionMethod extends AbstractFunction
  14 {
  15     /**
  16      * Doc block inherit tag for search
  17      */
  18     const INHERIT_TAG = '{@inheritdoc}';
  19
  20     /**
  21      * Parent class name
  22      * @var string
  23      */
  24     protected $class;
  25
  26     /**
  27      * Parent class reflection
  28      * @var ReflectionClass|\ReflectionClass
  29      */
  30     protected $classReflection;
  31
  32     /**
  33      * Constructor
  34      *
  35      * @param ReflectionClass $class
  36      * @param \ReflectionMethod $r
  37      * @param string $namespace
  38      * @param array $argv
  39      */
  40     public function __construct(ReflectionClass $class, \ReflectionMethod $r, $namespace = null, $argv = [])
  41     {
  42         $this->classReflection = $class;
  43         $this->reflection      = $r;
  44
  45         $classNamespace = $class->getNamespace();
  46
  47         // Determine namespace
  48         if (! empty($namespace)) {
  49             $this->setNamespace($namespace);
  50         } elseif (! empty($classNamespace)) {
  51             $this->setNamespace($classNamespace);
  52         }
  53
  54         // Determine arguments
  55         if (is_array($argv)) {
  56             $this->argv = $argv;
  57         }
  58
  59         // If method call, need to store some info on the class
  60         $this->class = $class->getName();
  61
  62         // Perform some introspection
  63         $this->reflect();
  64     }
  65
  66     /**
  67      * Return the reflection for the class that defines this method
  68      *
  69      * @return \Zend\Server\Reflection\ReflectionClass
  70      */
  71     public function getDeclaringClass()
  72     {
  73         return $this->classReflection;
  74     }
  75
  76     /**
  77      * Wakeup from serialization
  78      *
  79      * Reflection needs explicit instantiation to work correctly. Re-instantiate
  80      * reflection object on wakeup.
  81      *
  82      * @return void
  83      */
  84     public function __wakeup()
  85     {
  86         $this->classReflection = new ReflectionClass(
  87             new \ReflectionClass($this->class),
  88             $this->getNamespace(),
  89             $this->getInvokeArguments()
  90         );
  91         $this->reflection = new \ReflectionMethod($this->classReflection->getName(), $this->getName());
  92     }
  93
  94     /**
  95      * {@inheritdoc}
  96      */
  97     protected function reflect()
  98     {
  99         $docComment = $this->reflection->getDocComment();
 100         if (strpos($docComment, self::INHERIT_TAG) !== false) {
 101             $this->docComment = $this->fetchRecursiveDocComment();
 102         }
 103
 104         parent::reflect();
 105     }
 106
 107     /**
 108      * Fetch all doc comments for inherit values
 109      *
 110      * @return string
 111      */
 112     private function fetchRecursiveDocComment()
 113     {
 114         $currentMethodName = $this->reflection->getName();
 115         $docCommentList[] = $this->reflection->getDocComment();
 116
 117         // fetch all doc blocks for method from parent classes
 118         $docCommentFetched = $this->fetchRecursiveDocBlockFromParent($this->classReflection, $currentMethodName);
 119         if ($docCommentFetched) {
 120             $docCommentList = array_merge($docCommentList, $docCommentFetched);
 121         }
 122
 123
 124         // fetch doc blocks from interfaces
 125         $interfaceReflectionList = $this->classReflection->getInterfaces();
 126         foreach ($interfaceReflectionList as $interfaceReflection) {
 127             if (! $interfaceReflection->hasMethod($currentMethodName)) {
 128                 continue;
 129             }
 130
 131             $docCommentList[] = $interfaceReflection->getMethod($currentMethodName)->getDocComment();
 132         }
 133
 134         $normalizedDocCommentList = array_map(
 135             function ($docComment) {
 136                 $docComment = str_replace('/**', '', $docComment);
 137                 $docComment = str_replace('*/', '', $docComment);
 138
 139                 return $docComment;
 140             },
 141             $docCommentList
 142         );
 143
 144         $docComment = '/**' . implode(PHP_EOL, $normalizedDocCommentList) . '*/';
 145
 146         return $docComment;
 147     }
 148
 149     /**
 150      * Fetch recursive doc blocks from parent classes
 151      *
 152      * @param \ReflectionClass $reflectionClass
 153      * @param string           $methodName
 154      *
 155      * @return array|void
 156      */
 157     private function fetchRecursiveDocBlockFromParent($reflectionClass, $methodName)
 158     {
 159         $docComment = [];
 160         $parentReflectionClass = $reflectionClass->getParentClass();
 161         if (! $parentReflectionClass) {
 162             return;
 163         }
 164
 165         if (! $parentReflectionClass->hasMethod($methodName)) {
 166             return;
 167         }
 168
 169         $methodReflection = $parentReflectionClass->getMethod($methodName);
 170         $docCommentLast = $methodReflection->getDocComment();
 171         $docComment[] = $docCommentLast;
 172         if ($this->isInherit($docCommentLast)) {
 173             if ($docCommentFetched = $this->fetchRecursiveDocBlockFromParent($parentReflectionClass, $methodName)) {
 174                 $docComment = array_merge($docComment, $docCommentFetched);
 175             }
 176         }
 177
 178         return $docComment;
 179     }
 180
 181     /**
 182      * Return true if doc block inherit from parent or interface
 183      *
 184      * @param string $docComment
 185      *
 186      * @return bool
 187      */
 188     private function isInherit($docComment)
 189     {
 190         $isInherit = strpos($docComment, self::INHERIT_TAG) !== false;
 191
 192         return $isInherit;
 193     }
 194 }