PHP ReflectionFunctionAbstract::getDocComment方法代码示例

 public function __construct(ReflectionFunctionAbstract $method)
 {
     $this->name = $method->getShortName();
     $this->filename = $method->getFilename();
     $this->startline = $method->getStartLine();
     $this->endline = $method->getEndLine();
     $this->docstring = $method->getDocComment();
     $this->operator = $this->static ? Kint_Object::OPERATOR_STATIC : Kint_Object::OPERATOR_OBJECT;
     $this->access = Kint_Object::ACCESS_PUBLIC;
     if ($method instanceof ReflectionMethod) {
         $this->static = $method->isStatic();
         $this->abstract = $method->isAbstract();
         $this->final = $method->isFinal();
         $this->owner_class = $method->getDeclaringClass()->name;
         if ($method->isProtected()) {
             $this->access = Kint_Object::ACCESS_PROTECTED;
         } elseif ($method->isPrivate()) {
             $this->access = Kint_Object::ACCESS_PRIVATE;
         }
     }
     foreach ($method->getParameters() as $param) {
         $this->parameters[] = new Kint_Object_Parameter($param);
     }
     if ($this->docstring) {
         if (preg_match('/@return\\s+(.*)\\r?\\n/m', $this->docstring, $matches)) {
             if (!empty($matches[1])) {
                 $this->returntype = $matches[1];
             }
         }
     }
     $docstring = new Kint_Object_Representation_Docstring($this->docstring, $this->filename, $this->startline);
     $docstring->implicit_label = true;
     $this->addRepresentation($docstring);
 }

 /**
  * @param CollaboratorManager $collaborators
  * @param \ReflectionFunctionAbstract $function
  */
 private function generateCollaborators(CollaboratorManager $collaborators, \ReflectionFunctionAbstract $function)
 {
     if ($comment = $function->getDocComment()) {
         $comment = str_replace("\r\n", "\n", $comment);
         foreach (explode("\n", trim($comment)) as $line) {
             if (preg_match(self::$docex, $line, $match)) {
                 $collaborator = $this->getOrCreateCollaborator($collaborators, $match[2]);
                 $collaborator->beADoubleOf($match[1]);
             }
         }
     }
     foreach ($function->getParameters() as $parameter) {
         $collaborator = $this->getOrCreateCollaborator($collaborators, $parameter->getName());
         try {
             if (null !== ($class = $parameter->getClass())) {
                 $collaborator->beADoubleOf($class->getName());
             }
         } catch (ReflectionException $e) {
             throw new CollaboratorNotFoundException(sprintf('Collaborator does not exist '), 0, $e, $parameter);
         }
     }
 }

 /**
  * @param \ReflectionFunctionAbstract $function
  *
  * @return ReturnComment|false
  */
 public function parseDocComment(\ReflectionFunctionAbstract $function)
 {
     $docComment = $function->getDocComment();
     if (!$docComment) {
         return false;
     }
     if (preg_match('/\\*\\s*@return\\s(.*)/i', $docComment, $matches)) {
         return $this->parseReturnString($matches[1], $function);
     } elseif ($function instanceof \ReflectionMethod && false !== strpos($docComment, '{@inheritdoc}')) {
         /** @var \ReflectionMethod $function */
         $class = $function->getDeclaringClass();
         foreach ($class->getInterfaces() as $interface) {
             $result = $this->parseClassMethod($interface, $function->getName());
             if (false !== $result) {
                 return $result;
             }
         }
         if ($parent = $class->getParentClass()) {
             return $this->parseClassMethod($parent, $function->getName());
         }
     }
     return false;
 }

 /**
  * @param CollaboratorManager         $collaborators
  * @param \ReflectionFunctionAbstract $function
  */
 private function generateCollaborators(CollaboratorManager $collaborators, \ReflectionFunctionAbstract $function)
 {
     if ($comment = $function->getDocComment()) {
         $comment = str_replace("\r\n", "\n", $comment);
         foreach (explode("\n", trim($comment)) as $line) {
             if (preg_match(self::$docex, $line, $match)) {
                 $collaborator = $this->getOrCreateCollaborator($collaborators, $match[2]);
                 $collaborator->beADoubleOf($match[1]);
             }
         }
     }
     foreach ($function->getParameters() as $parameter) {
         $collaborator = $this->getOrCreateCollaborator($collaborators, $parameter->getName());
         if (null !== ($class = $parameter->getClass())) {
             $collaborator->beADoubleOf($class->getName());
         }
     }
 }

 /**
  * @param CollaboratorManager         $collaborators
  * @param \ReflectionFunctionAbstract $function
  * @param \ReflectionClass            $classRefl
  */
 private function generateCollaborators(CollaboratorManager $collaborators, \ReflectionFunctionAbstract $function, \ReflectionClass $classRefl)
 {
     if ($comment = $function->getDocComment()) {
         $comment = str_replace("\r\n", "\n", $comment);
         foreach (explode("\n", trim($comment)) as $line) {
             if (preg_match(self::$docex, $line, $match)) {
                 $collaborator = $this->getOrCreateCollaborator($collaborators, $match[2]);
                 $collaborator->beADoubleOf($match[1]);
             }
         }
     }
     foreach ($function->getParameters() as $parameter) {
         $collaborator = $this->getOrCreateCollaborator($collaborators, $parameter->getName());
         try {
             if ($this->isUnsupportedTypeHinting($parameter)) {
                 throw new InvalidCollaboratorTypeException($parameter, $function);
             }
             if (($indexedClass = $this->getParameterTypeFromIndex($classRefl, $parameter)) || ($indexedClass = $this->getParameterTypeFromReflection($parameter))) {
                 $collaborator->beADoubleOf($indexedClass);
             }
         } catch (ClassNotFoundException $e) {
             $this->throwCollaboratorNotFound($e, null, $e->getClassname());
         } catch (DisallowedScalarTypehintException $e) {
             throw new InvalidCollaboratorTypeException($parameter, $function);
         }
     }
 }

 /**
  *
  * @param EntityFunction $callable
  * @param \ReflectionFunctionAbstract $reflection
  * @return $this
  */
 public static function parseCallable(EntityFunction $callable, \ReflectionFunctionAbstract $reflection)
 {
     $doc = $reflection->getDocComment();
     $params = [];
     if ($doc) {
         $info = ToolKit::parseDoc($doc);
         $callable->setDescription($info['desc']);
         $callable->setReturnInfo($info['return']['type'], $reflection->returnsReference(), $info['return']['desc']);
         $callable->setOptions($info['options']);
         $params = $info["params"];
     } else {
         $info = [];
     }
     /* @var \ReflectionParameter[] $params */
     foreach ($reflection->getParameters() as $param) {
         $argument = new EntityArgument($param->name);
         if (isset($params[$param->name]["desc"])) {
             $argument->description = $params[$param->name]["desc"];
         }
         if ($callable->getLine()) {
             $argument->setLine($callable->getLine());
         }
         $argument->setOptional($param->isOptional());
         $argument->setNullAllowed($param->allowsNull());
         $argument->setValue($param->isDefaultValueAvailable() ? $param->getDefaultValue() : null, $param->isPassedByReference());
         $argument->setByRef($param->isPassedByReference());
         /** @var \ReflectionParameter $param */
         if ($param->isArray()) {
             $argument->setCast(Types::ARR);
         }
         if ($c = $param->getClass()) {
             $argument->setCast(Types::OBJECT, $c->name);
         } elseif (isset($info['params'][$param->name])) {
             $_type = $info['params'][$param->name]["type"];
             if (strpos($_type, "|") || $_type === "mixed") {
                 // multiple types or mixed
                 $argument->setCast(Types::MIXED);
             } else {
                 if (strpos($_type, "[]")) {
                     $argument->setCast(Types::ARR, rtrim($_type, '[]'));
                 }
                 if (isset(Types::$codes[$_type])) {
                     $argument->setCast(Types::getType($_type));
                 } else {
                     $argument->setCast(Types::OBJECT, ltrim($_type, '\\'));
                 }
             }
         } else {
             $argument->warning("not documented");
         }
         $callable->pushArgument($argument);
     }
 }

/**
 * Given some sort of reflection function/method object, return an array of docblock lines, where each line is an array of
 * keywords/descriptions
 *
 * @param ReflectionFunctionAbstract $function reflection function/method object from which to extract information
 *
 * @return array docblock converted in to an array
 */
function admin_mnet_method_get_docblock(ReflectionFunctionAbstract $function)
{
    return array_map(function ($line) {
        $text = trim($line, " \t\n\r\v*/");
        if (strpos($text, '@param') === 0) {
            return preg_split('/\\s+/', $text, 4);
        }
        if (strpos($text, '@return') === 0) {
            return preg_split('/\\s+/', $text, 3);
        }
        return array($text);
    }, explode("\n", $function->getDocComment()));
}

 /**
  * @param \ReflectionFunctionAbstract $reflection
  */
 public function setDocBlockFromReflection(\ReflectionFunctionAbstract $reflection)
 {
     $docBlock = $reflection->getDocComment();
     if ($docBlock) {
         $docBlock = preg_replace('/([\\n\\r])(' . self::$_indentation . ')+/', '$1', $docBlock);
         $this->setDocBlock($docBlock);
     }
 }

 /**
  * map a class method using reflection doc comment to get all comments to map
  * parameter type and method return value
  *
  * @error 14107
  * @param ReflectionFunctionAbstract $method expects the method to map
  * @return XO
  */
 protected function mapMethod(ReflectionFunctionAbstract $method)
 {
     $obj = new XO();
     $tmp = array();
     if (($comment = $method->getDocComment()) !== false) {
         $lines = preg_split('/\\n/', trim($comment));
         if (sizeof($lines) > 1) {
             $obj->description = array();
             $obj->params = array();
             $i = -1;
             foreach ($lines as $line) {
                 $i++;
                 if ($i === 0 || $i === sizeof($lines) - 1) {
                     continue;
                 }
                 if (stripos($line, '@') === false || stripos($line, '@desc') !== false) {
                     $line = str_replace(array("\n", "\r\n", "\t"), '', trim($line));
                     $line = preg_replace(array('/\\@desc/i', '/^\\*\\/?\\s*/'), array('', ''), $line);
                     if (!empty($line)) {
                         $tmp[] = $line;
                     }
                 }
                 if (stripos($line, '@param') !== false || stripos($line, '@return') !== false) {
                     $line = str_replace(array("\t", "\n", "\r"), '', trim($line));
                     $line = substr($line, strpos($line, '@'));
                     $line = preg_replace(array('/[ \\s]+/', '/[ \\s]\\|[ \\s]/'), array(' ', '|'), $line);
                     $word = preg_split('/\\s+/i', $line);
                     $word = strtolower($word[1]);
                     if (stripos($word, '|') !== false) {
                         $word = explode('|', $word);
                     }
                     if (stripos($line, '@param') !== false) {
                         if (preg_match('/\\$\\w+\\b(.*)$/isD', $line, $m)) {
                             $obj->params['description'][] = trim($m[1]);
                         } else {
                             $obj->params['description'][] = null;
                         }
                         if (is_string($word) && stripos($word, '$') !== false) {
                             $obj->params['type'][] = 'mixed';
                         } else {
                             $obj->params['type'][] = self::mapType($word);
                         }
                     }
                     if (stripos($line, '@return') !== false) {
                         $obj->returns = self::mapType($word);
                     }
                 }
             }
             if (!empty($tmp)) {
                 $obj->description = implode(" ", $tmp);
             }
         }
     }
     return $obj;
 }

 /**
  * Import callable info from reflection
  *
  * @param \ReflectionFunctionAbstract $method
  *
  * @return static
  */
 protected function _importFromReflection(\ReflectionFunctionAbstract $method)
 {
     $doc = $method->getDocComment();
     $doc_params = [];
     $this->return = new ReturnInfo($this);
     if ($doc) {
         $doc = preg_replace('/^\\s*(\\*\\s*)+/mS', '', trim($doc, "*/ \t\n\r"));
         if (strpos($doc, "@") !== false) {
             $doc = explode("@", $doc, 2);
             if ($doc[0] = trim($doc[0])) {
                 $this->desc = $doc[0];
             }
             if ($doc[1]) {
                 foreach (preg_split('/\\r?\\n@/mS', $doc[1]) as $param) {
                     $param = preg_split('/\\s+/S', $param, 2);
                     if (!isset($param[1])) {
                         $param[1] = "";
                     }
                     switch (strtolower($param[0])) {
                         case 'description':
                             if (empty($this->desc)) {
                                 $this->desc = $param[1];
                             }
                             break;
                         case 'param':
                             if (preg_match('/^(.*?)\\s+\\$(\\w+)\\s*(?:\\(([^\\)]+)\\))?/mS', $param[1], $matches)) {
                                 $this->params[$matches[2]] = ["type" => $matches[1], "desc" => trim(substr($param[1], strlen($matches[0]))), "filters" => isset($matches[3]) ? Filter::parseDoc($matches[3]) : []];
                             }
                             break;
                         case 'return':
                             $return = preg_split('~\\s+~mS', $param[1], 2);
                             if ($return) {
                                 $this->return->type = $return[0];
                                 if (count($return) == 2) {
                                     $this->return->desc = $return[1];
                                 }
                             }
                             break;
                         default:
                             if (isset($this->options[$param[0]])) {
                                 $this->options[$param[0]][] = $param[1];
                             } else {
                                 $this->options[$param[0]] = [$param[1]];
                             }
                     }
                 }
             }
         } else {
             $this->desc = $doc;
         }
     }
     foreach ($method->getParameters() as $param) {
         $this->args[$param->name] = $arg = new ArgumentInfo($this);
         $arg->import($param);
     }
     return $this;
 }