php phpDocumentor-Reflection-DocBlock类(方法)实例源码

/**
  * Generate docblock.
  *
  * @param string $class
  * @param array $properties
  * @param array $methods
  * @return mixed
  */
 public function docblock($class, $properties, $methods)
 {
     $phpdoc = new DocBlock('');
     $phpdoc->setText($class);
     foreach ($properties as $property) {
         $tag = Tag::createInstance("@{$property['type']} {$property['return']} {$property['name']}", $phpdoc);
         $phpdoc->appendTag($tag);
     }
     foreach ($methods as $method) {
         $tag = Tag::createInstance("@method {$method['type']} {$method['return']} {$method['name']}({$method['arguments']})", $phpdoc);
         $phpdoc->appendTag($tag);
     }
     $serializer = new DocBlockSerializer();
     $docComment = $serializer->getDocComment($phpdoc);
     return $docComment;
 }

/**
  * Parses doc comment and populates comment entity
  *
  * @param string $text
  */
 protected function parseDoc(Comment $comment, $text)
 {
     $context = $this->getContext();
     try {
         $block = new DocBlock($text, $context);
         foreach ($block->getTags() as $tag) {
             switch ($tag->getName()) {
                 case "param":
                     $comment->addVar($this->createMethodParam($tag));
                     break;
                 case "var":
                     $comment->addVar($this->createVar($tag));
                     break;
                 case "return":
                     $comment->setReturn($this->getFQCN($tag->getType()));
                     break;
                 case "property":
                     $comment->addProperty($this->createProperty($tag));
                     break;
                 case "inheritdoc":
                     $comment->markInheritDoc();
                     break;
             }
         }
     } catch (\Exception $e) {
     }
 }

/**
  * Constructor
  *
  * @param string             $name     Name of the "entity"
  * @param DocBlock|null      $docblock Docblock
  * @param BaseReflector|null $source   Source Element.
  */
 public function __construct($name, $docblock = null, $source = null)
 {
     $this->entityName = $name;
     $this->lineNumber = $docblock ? $docblock->getLocation()->getLineNumber() : $source->getLineNumber();
     $this->docblock = $docblock;
     $this->source = $source;
 }

protected function configure()
 {
     $reflection = new \ReflectionClass(get_called_class());
     $baseNamespaceChunks = [];
     foreach (explode('\\', $reflection->getNamespaceName()) as $namespaceChunk) {
         $baseNamespaceChunks[] = $namespaceChunk;
         if ($namespaceChunk == consoleBase::COMMANDS_DIRECTORY) {
             break;
         }
     }
     $namespace = str_replace(implode('\\', $baseNamespaceChunks), '', get_called_class());
     $namespace = trim($namespace, '\\');
     $commandNameData = explode('\\', $namespace);
     $phpdoc = new DocBlock($reflection);
     /** @var DocBlock\Tag $tag */
     $tag = reset($phpdoc->getTagsByName('consoleNs'));
     $commandNameValues = [];
     if ($tag) {
         $consoleNs = trim($tag->getDescription());
         if (!empty($consoleNs)) {
             $commandNameValues[] = $consoleNs;
         }
     }
     foreach ($commandNameData as $commandNameValue) {
         $commandNameValues[] = $commandNameValue;
     }
     $this->setName(implode(':', $commandNameValues))->setDescription($phpdoc->getShortDescription())->setHelp($phpdoc->getLongDescription());
     $this->defineArguments();
 }

protected function getProperties($propertyName)
 {
     $reflection = new \ReflectionClass($this->model);
     $docBlock = new DocBlock($reflection);
     $properties = $docBlock->getTagsByName($propertyName);
     return $this->buildProperties($properties);
 }

/**
  * Constructor
  *
  * @param \phpDocumentor\Plugin\Plugin            $plugin     Plugin to which this
  *     validator belongs.
  * @param string                                  $name       Name of the "entity"
  * @param \phpDocumentor\Reflection\DocBlock|null $docblock   Docblock
  * @param \phpDocumentor\Reflection\BaseReflector|null  $source     Source Element.
  */
 public function __construct($plugin, $name, $docblock = null, $source = null)
 {
     $this->entityName = $name;
     $this->lineNumber = $docblock ? $docblock->getLocation()->getLineNumber() : $source->getLineNumber();
     $this->docblock = $docblock;
     $this->source = $source;
     parent::__construct($plugin->getEventDispatcher(), $plugin->getConfiguration(), $plugin->getTranslator());
 }

/**
  * Parse the docBlock comment for this command, and set the
  * fields of this class with the data thereby obtained.
  */
 public function parse()
 {
     $docblockComment = $this->reflection->getDocComment();
     $phpdoc = new DocBlock($docblockComment);
     // First set the description (synopsis) and help.
     $this->commandInfo->setDescription((string) $phpdoc->getShortDescription());
     $this->commandInfo->setHelp((string) $phpdoc->getLongDescription());
     $this->processAllTags($phpdoc);
 }

/**
  * @param string $method
  * @return array
  */
 public function getMethodDecorators($method)
 {
     $reflectionMethod = new \ReflectionMethod($this->getInstance(), $method);
     $docBlock = new DocBlock($reflectionMethod);
     $decorators = [];
     foreach ($docBlock->getTagsByName(static::TAG_NAME) as $tag) {
         $decorators[] = $tag->getContent();
     }
     return $decorators;
 }

/**
  * Extracts the package from the DocBlock.
  *
  * @param DocBlock $docBlock
  *
  * @return string|null
  */
 protected function extractPackageFromDocBlock($docBlock)
 {
     $packageTags = $docBlock ? $docBlock->getTagsByName('package') : null;
     if (!$packageTags) {
         return null;
     }
     /** @var DocBlock\Tag $tag */
     $tag = reset($packageTags);
     return trim($tag->getContent());
 }

/**
  * @param \ReflectionProperty $reflectionProperty
  *
  * @return string|null
  */
 public function detectType(\ReflectionProperty $reflectionProperty)
 {
     $docBlock = new DocBlock($reflectionProperty->getDocComment());
     $tags = $docBlock->getTagsByName('var');
     if (count($tags) == 0) {
         return null;
     }
     /** @var VarTag $typeTag */
     $typeTag = reset($tags);
     return $typeTag->getType();
 }

/**
  * Discover Magical API
  *
  * @param ClassNode $node
  */
 public function apply(ClassNode $node)
 {
     $parentClass = $node->getParentClass();
     $reflectionClass = new \ReflectionClass($parentClass);
     $phpdoc = new DocBlock($reflectionClass->getDocComment());
     $tagList = $phpdoc->getTagsByName('method');
     foreach ($tagList as $tag) {
         $methodNode = new MethodNode($tag->getMethodName());
         $methodNode->setStatic($tag->isStatic());
         $node->addMethod($methodNode);
     }
 }

/**
  * 
  * @param ReflectionProperty $reflector
  * @return ParsePropertyBlockResult
  */
 public function parsePropertyDocBlock(ReflectionProperty $reflector)
 {
     $phpdoc = new DocBlock($reflector->getDocComment());
     /* @var $varTags VarTag[] */
     $varTags = $phpdoc->getTagsByName("var");
     /* @var $varTag VarTag */
     $varTag = $varTags[0];
     $result = new ParsePropertyBlockResult();
     $result->description = $phpdoc->getShortDescription();
     $result->type = (string) $varTag->getType();
     return $result;
 }

/**
  * @param $doc
  * @return bool
  */
 public function parseClass(ControllerDoc $doc)
 {
     if (!($docBlock = new DocBlock($this->reflection))) {
         return false;
     }
     $doc->longDescription = $docBlock->getLongDescription()->getContents();
     $doc->shortDescription = $docBlock->getShortDescription();
     $doc->populateTags($docBlock);
     if (DocBlockHelper::isInherit($docBlock)) {
         $parentParser = $this->getParentParser();
         $parentParser->parseClass($doc);
     }
 }

/**
  * Given a property, attempt to find the type of the property.
  *
  * @param ReflectionProperty $reflectionProperty
  * @return Type[]
  */
 public function __invoke(ReflectionProperty $reflectionProperty)
 {
     $contextFactory = new ContextFactory();
     $context = $contextFactory->createForNamespace($reflectionProperty->getDeclaringClass()->getNamespaceName(), $reflectionProperty->getDeclaringClass()->getLocatedSource()->getSource());
     $docBlock = new DocBlock($reflectionProperty->getDocComment(), new DocBlock\Context($context->getNamespace(), $context->getNamespaceAliases()));
     /* @var \phpDocumentor\Reflection\DocBlock\Tag\VarTag $varTag */
     $resolvedTypes = [];
     $varTags = $docBlock->getTagsByName('var');
     foreach ($varTags as $varTag) {
         $resolvedTypes = array_merge($resolvedTypes, (new ResolveTypes())->__invoke($varTag->getTypes(), $context));
     }
     return $resolvedTypes;
 }

/**
  * Given a function and parameter, attempt to find the type of the parameter.
  *
  * @param ReflectionFunctionAbstract $function
  * @param ParamNode $node
  * @return Type[]
  */
 public function __invoke(ReflectionFunctionAbstract $function, ParamNode $node)
 {
     $context = $this->createContextForFunction($function);
     $docBlock = new DocBlock($function->getDocComment(), new DocBlock\Context($context->getNamespace(), $context->getNamespaceAliases()));
     $paramTags = $docBlock->getTagsByName('param');
     foreach ($paramTags as $paramTag) {
         /* @var $paramTag \phpDocumentor\Reflection\DocBlock\Tag\ParamTag */
         if ($paramTag->getVariableName() === '$' . $node->name) {
             return (new ResolveTypes())->__invoke($paramTag->getTypes(), $context);
         }
     }
     return [];
 }

/**
  * {@inheritDoc}
  */
 public function extractAction(ActionInterface $action)
 {
     $callable = $this->callableResolver->resolve($action);
     if ($this->parameterExtractor) {
         $parameters = $this->parameterExtractor->extract($action, $callable);
     } else {
         $parameters = [];
     }
     $reflection = $callable->getReflection();
     $docBlock = new DocBlock($reflection);
     $description = $docBlock->getShortDescription();
     $actionDoc = new Action($action->getName(), $description, $parameters);
     return $actionDoc;
 }

/**
  * Factory method responsible for instantiating the correct sub type.
  *
  * @param string   $tag_line The text for this tag, including description.
  * @param DocBlock $docblock The DocBlock which this tag belongs to.
  * @param Location $location Location of the tag.
  *
  * @throws \InvalidArgumentException if an invalid tag line was presented.
  *
  * @return static A new tag object.
  */
 public static final function createInstance($tag_line, DocBlock $docblock = null, Location $location = null)
 {
     $matches = self::extractTagParts($tag_line);
     $handler = __CLASS__;
     if (isset(self::$tagHandlerMappings[$matches[1]])) {
         $handler = self::$tagHandlerMappings[$matches[1]];
     } elseif (isset($docblock)) {
         $tagName = (string) new Type\Collection(array($matches[1]), $docblock->getContext());
         if (isset(self::$tagHandlerMappings[$tagName])) {
             $handler = self::$tagHandlerMappings[$tagName];
         }
     }
     return new $handler($matches[1], isset($matches[2]) ? $matches[2] : '', $docblock, $location);
 }

/**
  * Process comments into docblock objects.
  * @param array $docblocks
  */
 protected function processDocBlocks(array $docblocks)
 {
     $this->docblocks = array();
     foreach ($docblocks as $raw_docblock) {
         $docblock = new DocBlock($raw_docblock);
         $tags = $docblock->getTagsByName("var");
         foreach ($tags as $tag) {
             if ($tag && ($description = $tag->getDescription())) {
                 list($key, ) = explode(' ', $description);
                 $this->docblocks[$key] = $docblock;
             }
         }
     }
 }

/**
  * Extracts tags from docBlock and adds it to document.
  *
  * @param DocBlock $docBlock
  */
 public function populateTags(DocBlock $docBlock)
 {
     $tags = $docBlock->getTags();
     $offset = strlen(self::TAG_PREFIX);
     foreach ($tags as $tag) {
         $name = $tag->getName();
         if (strpos($name, self::TAG_PREFIX) === 0) {
             $key = substr($name, $offset);
             if (!isset($this->_tags)) {
                 $this->_tags[$key] = [];
             }
             $this->_tags[$key][] = $tag;
         }
     }
 }

protected function setParentsPackage(\DOMElement $parent, \phpDocumentor\Reflection\DocBlock $docblock, $element)
 {
     /** @var \phpDocumentor\Reflection\DocBlock\Tag $package */
     $package = current($docblock->getTagsByName('package'));
     /** @var \phpDocumentor\Reflection\DocBlock\Tag $subpackage */
     $subpackage = current($docblock->getTagsByName('subpackage'));
     $package_name = '';
     if ($package) {
         $package_name = str_replace(array('.', '_'), '\\', $package->getContent() . ($subpackage ? '\\' . $subpackage->getContent() : ''));
     }
     if (!$package_name) {
         $package_name = $element->getDefaultPackageName();
     }
     $parent->setAttribute('package', $package_name);
 }