/**
* Filter Descriptor with based on visibility.
*
* @param DescriptorAbstract $value
*
* @return DescriptorAbstract|null
*/
public function filter($value)
{
if ($value instanceof VisibilityInterface && !$this->builder->isVisibilityAllowed($value->getVisibility())) {
return null;
}
return $value;
}
/**
* Retrieves the File Descriptor from the given element.
*
* @param DescriptorAbstract $element
*
* @throws \UnexpectedValueException if the provided element does not have a file associated with it.
*
* @return FileDescriptor
*/
protected function getFileDescriptor($element)
{
$fileDescriptor = $element instanceof FileDescriptor ? $element : $element->getFile();
if (!$fileDescriptor instanceof FileDescriptor) {
throw new \UnexpectedValueException('An element should always have a file associated with it');
}
return $fileDescriptor;
}
/**
* Generates a URL from the given node or returns false if unable.
*
* @param DescriptorAbstract $node
*
* @return string|false
*/
public function __invoke($node)
{
$name = str_replace('\\', '.', ltrim($node->getFullyQualifiedStructuralElementName(), '\\'));
// convert root namespace to default; default is a keyword and no namespace CAN be named as such
if ($name === '') {
$name = 'default';
}
return '/packages/' . $name . '.html';
}
/**
* Overrides the name and namespace of an element with a separated version of the class name.
*
* If a class is separated by underscores than the last part is set as name and the first parts are set as
* namespace with the namespace separator instead of an underscore.
*
* @param DescriptorAbstract $value
*
* @return DescriptorAbstract|null
*/
public function filter($value)
{
if ($value) {
$namespace = $value->getNamespace() == '' ? '\\' . $this->namespacePrefix : $value->getNamespace();
$value->setNamespace($this->namespaceFromLegacyNamespace($namespace, $value->getName()));
$value->setName($this->classNameFromLegacyNamespace($value->getName()));
}
return $value;
}
/**
* Assemble DocBlock.
*
* @param DocBlock|null $docBlock
* @param DescriptorAbstract $target
*
* @return void
*/
protected function assembleDocBlock($docBlock, $target)
{
if (!$docBlock) {
return;
}
$target->setSummary($docBlock->getShortDescription());
$target->setDescription($docBlock->getLongDescription()->getContents());
/** @var DocBlock\Tag $tag */
foreach ($docBlock->getTags() as $tag) {
$tagDescriptor = $this->builder->buildDescriptor($tag);
// allow filtering of tags
if (!$tagDescriptor) {
continue;
}
$target->getTags()->get($tag->getName(), new Collection())->add($tagDescriptor);
}
}
/**
* Initializes a new file descriptor with the given hash of its contents.
*
* @param string $hash An MD5 hash of the contents if this file.
*/
public function __construct($hash)
{
parent::__construct();
$this->setHash($hash);
$this->setNamespaceAliases(new Collection());
$this->setIncludes(new Collection());
$this->setConstants(new Collection());
$this->setFunctions(new Collection());
$this->setClasses(new Collection());
$this->setInterfaces(new Collection());
$this->setTraits(new Collection());
$this->setMarkers(new Collection());
}
/**
* If the ProjectDescriptor's settings allow internal tags then return the Descriptor, otherwise null to filter it.
*
* @param DescriptorAbstract $value
*
* @return DescriptorAbstract|null
*/
public function filter($value)
{
$isInternalAllowed = $this->builder->isVisibilityAllowed(Settings::VISIBILITY_INTERNAL);
if ($isInternalAllowed) {
$value->setDescription(preg_replace('/{@internal\\ (.+)}}/', '$1', $value->getDescription()));
return $value;
}
// remove inline @internal tags
$value->setDescription(preg_replace('/{@internal\\ .+}}/', '', $value->getDescription()));
// if internal elements are not allowed; filter this element
if ($value->getTags()->get('internal')) {
return null;
}
return $value;
}
/**
* Replaces the example tags in the description with the contents of the found example.
*
* @param DescriptorAbstract $element
*
* @return string
*/
protected function replaceInlineExamples(DescriptorAbstract $element)
{
$description = $element->getDescription();
$matches = array();
if (!$description || !preg_match_all('/\\{@example\\s(.+?)\\}/', $description, $matches) || count($matches[0]) < 1) {
return $description;
}
$matched = array();
foreach ($matches[0] as $index => $match) {
if (isset($matched[$match])) {
continue;
}
$matched[$match] = true;
$exampleReflector = new ExampleTag('example', $matches[1][$index]);
$example = $this->exampleAssembler->create($exampleReflector);
$replacement = '`' . $example->getExample() . '`';
if ($example->getDescription()) {
$replacement = '*' . $example->getDescription() . '*' . $replacement;
}
$description = str_replace($match, $replacement, $description);
}
return $description;
}
/**
* Adds each tag to the $xml_node.
*
* @param \DOMElement $xml_node
* @param DescriptorAbstract $element
*
* @return void
*/
protected function addTags(\DOMElement $xml_node, $element)
{
foreach ($element->getTags() as $tagGroup) {
if ($tagGroup === null) {
continue;
}
foreach ($tagGroup as $tag) {
$this->buildDocBlockTag($xml_node, $tag, $element);
}
}
}
/**
* @covers phpDocumentor\Descriptor\DescriptorAbstract::__toString
*/
public function testToString()
{
$this->fixture->setFullyQualifiedStructuralElementName('fqn');
$this->assertSame('fqn', (string) $this->fixture);
}
/**
* Normalizes the given FQSEN as if the context marker represents a class/interface/trait as parent.
*
* @param string $fqsen
* @param DescriptorAbstract $container
*
* @return string
*/
protected function getTypeWithNamespaceAsContext($fqsen, DescriptorAbstract $container)
{
$namespace = $container instanceof NamespaceDescriptor ? $container : $container->getNamespace();
$fqnn = $namespace instanceof NamespaceDescriptor ? $namespace->getFullyQualifiedStructuralElementName() : $namespace;
return str_replace(self::CONTEXT_MARKER . '::', $fqnn . '\\', $fqsen);
}
/**
* Creates a DocBlock context containing the namespace and aliases for the current descriptor.
*
* @return Context
*/
private function createDocBlockContext()
{
$file = $this->descriptor->getFile();
$namespaceAliases = $file ? $file->getNamespaceAliases()->getAll() : array();
return new Context($this->descriptor->getNamespace(), $namespaceAliases);
}
/**
* Adds the 'inherited_from' tag when a Descriptor inherits from another Descriptor.
*
* @param \DOMElement $docBlock
* @param DescriptorAbstract $descriptor
*
* @return void
*/
protected function addInheritedFromTag(\DOMElement $docBlock, $descriptor)
{
$parentElement = $descriptor->getInheritedElement();
if (!$parentElement instanceof $descriptor) {
return;
}
$child = new \DOMElement('tag');
$docBlock->appendChild($child);
$rule = $this->router->match($parentElement);
$child->setAttribute('name', 'inherited_from');
$child->setAttribute('description', $parentElement->getFullyQualifiedStructuralElementName());
$child->setAttribute('refers', $parentElement->getFullyQualifiedStructuralElementName());
$child->setAttribute('link', $rule ? $rule->generate($parentElement) : '');
}
/**
* This implements testing of the protected buildDocBlock method
*
* @param DescriptorAbstract $descriptor
* @return void
*/
protected function implementProtectedBuildDocBlock(DescriptorAbstract $descriptor)
{
$descriptor->shouldReceive('getLine')->andReturn(666);
$descriptor->shouldReceive('getPackage')->andReturn('myPackage');
$descriptor->shouldReceive('getSummary')->andReturn('my summary');
$descriptor->shouldReceive('getDescription')->andReturn('my description');
$descriptor->shouldReceive('getTags')->andReturn(array());
}
/**
* Describes when a descriptor has tags.
*
* @param DescriptorAbstract|m\MockInterface $descriptor
* @param array $tags
*
* @return void
*/
protected function whenDescriptorHasTags($descriptor, $tags)
{
$descriptor->shouldReceive('getTags')->andReturn($tags);
}
/**
* Returns the file associated with the parent class, interface or trait when inside a container.
*
* @return FileDescriptor
*/
public function getFile()
{
return parent::getFile() ?: $this->getParent()->getFile();
}
/**
* Retrieves a key for the index for the provided element.
*
* @param DescriptorAbstract $element
*
* @return string
*/
protected function getIndexKey($element)
{
$key = $element->getFullyQualifiedStructuralElementName();
// properties should have an additional $ before the property name
if ($element instanceof PropertyInterface) {
list($fqcn, $propertyName) = explode('::', $key);
$key = $fqcn . '::$' . $propertyName;
}
return $key;
}
/**
* Generates a URL from the given node or returns false if unable.
*
* @param DescriptorAbstract $node
*
* @return string|false
*/
public function __invoke($node)
{
return '/classes/' . str_replace('\\', '.', ltrim($node->getFullyQualifiedStructuralElementName(), '\\')) . '.html';
}
/**
* @param DescriptorAbstract $descriptor
* @param string $description
*/
protected function givenDescriptorHasTodoTagWithDescription($descriptor, $description)
{
$todoTag = new TagDescriptor('todo');
$todoTag->setDescription($description);
$todoTags = $descriptor->getTags()->get('todo', array());
$todoTags[] = $todoTag;
$descriptor->getTags()->set('todo', $todoTags);
}
/**
* Uses the currently selected node and transformation to assemble the destination path for the file.
*
* @param DescriptorAbstract $node
* @param Transformation $transformation
*
* @return string|false returns the destination location or false if generation should be aborted.
*/
protected function getDestinationPath($node, Transformation $transformation)
{
$this->destinationPath = $this->destinationPath ?: sys_get_temp_dir() . DIRECTORY_SEPARATOR . md5($node->getName());
return $this->destinationPath;
}
/**
* Generates a URL from the given node or returns false if unable.
*
* @param DescriptorAbstract $node
*
* @return string|false
*/
public function __invoke($node)
{
$name = str_replace(array('/', '\\'), '.', ltrim($node->getPath(), '/'));
return '/files/' . $name . '.html';
}