ApiGen\Templating\Filters\UrlFilters

Complexity

Total Complexity

43

Size/Duplication

Total Lines	251
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

98.15%

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	13	1
B	resolveLink()	0	26	6
A	annotation()	0	17	2
A	typeLinks()	0	16	3
A	annotationDescription()	0	5	2
A	description()	0	13	2
A	doc()	0	9	1
A	resolveInternalAnnotation()	0	11	2
A	resolveLinkAndSeeAnnotation()	0	17	4
A	highlightPhp()	0	5	2
A	highlightValue()	0	4	1
A	processReturnAnnotations()	0	6	1
A	processThrowsAnnotations()	0	6	1
A	getDescriptionFromValue()	0	9	3
A	processLicenseAnnotations()	0	5	2
A	processLinkAnnotations()	0	9	3
A	processSeeAnnotations()	0	13	3
A	processUsesAnnotations()	0	11	4

<?php declare(strict_types=1);

namespace ApiGen\Templating\Filters;

use ApiGen\Contracts\Generator\Resolvers\ElementResolverInterface;
use ApiGen\Contracts\Generator\SourceCodeHighlighter\SourceCodeHighlighterInterface;
use ApiGen\Contracts\Parser\Reflection\ClassReflectionInterface;
use ApiGen\Contracts\Parser\Reflection\ElementReflectionInterface;
use ApiGen\Contracts\Parser\Reflection\FunctionReflectionInterface;
use ApiGen\Event\ProcessDocTextEvent;
use ApiGen\Templating\Filters\Helpers\ElementLinkFactory;
use ApiGen\Templating\Filters\Helpers\LinkBuilder;
use ApiGen\Templating\Filters\Helpers\Strings;
use Latte\Runtime\Filters as LatteFilters;
use Nette\Utils\Validators;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;

final class UrlFilters extends Filters
{
    /**
     * @var SourceCodeHighlighterInterface
     */
    private $highlighter;

    /**
     * @var ElementResolverInterface
     */
    private $elementResolver;

    /**
     * @var LinkBuilder
     */
    private $linkBuilder;

    /**
     * @var ElementLinkFactory
     */
    private $elementLinkFactory;

    /**
     * @var EventDispatcherInterface
     */
    private $eventDispatcher;

    public function __construct(
        SourceCodeHighlighterInterface $highlighter,
        ElementResolverInterface $elementResolver,
        LinkBuilder $linkBuilder,
        ElementLinkFactory $elementLinkFactory,
        EventDispatcherInterface $eventDispatcher
    ) {
        $this->highlighter = $highlighter;
        $this->elementResolver = $elementResolver;
        $this->linkBuilder = $linkBuilder;
        $this->elementLinkFactory = $elementLinkFactory;
        $this->eventDispatcher = $eventDispatcher;
    }

    /**
     * Tries to parse a definition of a class/method/property/constant/function
     * and returns the appropriate link if successful.
     */
    public function resolveLink(string $definition, ElementReflectionInterface $reflectionElement): ?string
    {
        if (empty($definition)) {
            return null;
        }

        $suffix = '';
        if (substr($definition, -2) === '[]') {
            $definition = substr($definition, 0, -2);
            $suffix = '[]';
        }

        $element = $this->elementResolver->resolveElement($definition, $reflectionElement, $expectedName);
        if ($element === null || $element instanceof FunctionReflectionInterface) {
            return $expectedName;
        }

        $classes = [];
        if ($element->isDeprecated()) {
            $classes[] = 'deprecated';
        }

        $link = $this->elementLinkFactory->createForElement($element, $classes);

It seems like $element defined by $this->elementResolver->resolveElement($definition, $reflectionElement, $expectedName) on line 75 can also be of type boolean; however, ApiGen\Templating\Filters\Helpers\ElementLinkFactory::createForElement() does only seem to accept object<ApiGen\Contracts\Parser\Reflection\ElementReflectionInterface>, maybe add an additional type check?

        return '<code>' . $link . $suffix . '</code>';
    }

    public function annotation(string $value, string $name, ElementReflectionInterface $reflectionElement): string
    {
        $annotationProcessors = [
            'return' => $this->processReturnAnnotations($value, $reflectionElement),
            'throws' => $this->processThrowsAnnotations($value, $reflectionElement),
            'license' => $this->processLicenseAnnotations($value),
            'link' => $this->processLinkAnnotations($value),
            'see' => $this->processSeeAnnotations($value, $reflectionElement),
            'uses' => $this->processUsesAnnotations($value, $reflectionElement),
        ];

        if (isset($annotationProcessors[$name])) {
            return $annotationProcessors[$name];
        }

        return $this->doc($value, $reflectionElement);
    }

    /**
     * Returns links for types.
     */
    public function typeLinks(string $annotation, ElementReflectionInterface $reflectionElement): string
    {
        $links = [];

        // typehints can not contain spaces
        // valid typehint is:
        // [TYPE[|TYPE[|...]][SPACE[METHOD|PARAM][DESCRIPTION]]

69% of this comment could be valid code. Did you maybe forget this after debugging?

        $parts = explode(' ', $annotation);

        foreach (explode('|', $parts[0]) as $type) {
            $type = $this->getTypeName($type, false);
            $links[] = $this->resolveLink($type, $reflectionElement) ?: LatteFilters::escapeHtml(ltrim($type, '\\'));
        }

        return implode('|', $links);
    }

    public function annotationDescription(string $annotation, ElementReflectionInterface $reflectionElement): string
    {
        $description = trim(strpbrk($annotation, "\n\r\t $")) ?: $annotation;
        return $this->doc($description, $reflectionElement);
    }

    public function description(ElementReflectionInterface $element): string
    {
        $long = $element->getDescription();

        // Merge lines
        $long = preg_replace_callback('~(?:<(code|pre)>.+?</\1>)|([^<]*)~s', function ($matches) {
            return ! empty($matches[2])
                ? preg_replace('~\n(?:(\s+\n){2,})+~', ' ', $matches[2])
                : $matches[0];
        }, $long);

        return $this->doc($long, $element);
    }

    public function doc(string $text, ElementReflectionInterface $reflectionElement): string
    {
        $text = $this->resolveInternalAnnotation($text);

        $processDocTextEvent = new ProcessDocTextEvent($text, $reflectionElement);
        $this->eventDispatcher->dispatch(ProcessDocTextEvent::class, $processDocTextEvent);

        return $this->resolveLinkAndSeeAnnotation($processDocTextEvent->getText(), $reflectionElement);
    }

    private function resolveInternalAnnotation(string $text): string
    {
        $pattern = '~\\{@(\\w+)(?:(?:\\s+((?>(?R)|[^{}]+)*)\\})|\\})~';
        return preg_replace_callback($pattern, function ($matches) {
            if ($matches[1] !== 'internal') {
                return $matches[0];
            }

            return '';
        }, $text);
    }

    private function resolveLinkAndSeeAnnotation(string $text, ElementReflectionInterface $reflectionElement): string
    {
        return preg_replace_callback('~{@(?:link|see)\\s+([^}]+)}~', function ($matches) use ($reflectionElement) {
            [$url, $description] = Strings::split($matches[1]);

The variable $url does not exist. Did you forget to declare it?

The variable $description does not exist. Did you forget to declare it?

            $link = $this->resolveLink($matches[1], $reflectionElement);
            if ($link) {

The expression $link of type null|string is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

                return $link;
            }

            if (Validators::isUri($url)) {
                return $this->linkBuilder->build($url, $description ?: $url);
            }

            return $matches[1];
        }, $text);
    }

    public function highlightPhp(string $source, ElementReflectionInterface $reflectionElement): string
    {
        return $this->resolveLink($this->getTypeName($source), $reflectionElement)
            ?: $this->highlighter->highlight((string) $source);
    }

    public function highlightValue(string $definition, ElementReflectionInterface $reflectionElement): string
    {
        return $this->highlightPhp(preg_replace('~^(?:[ ]{4}|\t)~m', '', $definition), $reflectionElement);
    }

    private function processReturnAnnotations(string $value, ElementReflectionInterface $reflectionElement): string
    {
        $description = $this->getDescriptionFromValue($value, $reflectionElement);
        $typeLinks = $this->typeLinks($value, $reflectionElement);
        return $typeLinks . $description;
    }

    private function processThrowsAnnotations(string $value, ElementReflectionInterface $elementReflection): string
    {
        $description = $this->getDescriptionFromValue($value, $elementReflection);
        $typeLinks = $this->typeLinks($value, $elementReflection);
        return $typeLinks . $description;
    }

    /**
     * @param mixed $value
     * @param ElementReflectionInterface $elementReflection
     */
    private function getDescriptionFromValue($value, ElementReflectionInterface $elementReflection): string
    {
        $description = (string) trim((string) strpbrk($value, "\n\r\t $")) ?: null;
        if ($description) {

The expression $description of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $description = '<br>' . $this->doc($description, $elementReflection);
        }

        return (string) $description;
    }

    private function processLicenseAnnotations(string $value): string
    {
        [$url, $description] = Strings::split($value);

The variable $url does not exist. Did you forget to declare it?

The variable $description does not exist. Did you forget to declare it?

        return $this->linkBuilder->build($url, $description ?: $url);
    }

    private function processLinkAnnotations(string $value): string
    {
        [$url, $description] = Strings::split($value);

The variable $url does not exist. Did you forget to declare it?

The variable $description does not exist. Did you forget to declare it?

        if (Validators::isUrl($url)) {
            return $this->linkBuilder->build($url, $description ?: $url);
        }

        return '';
    }

    private function processSeeAnnotations(string $value, ElementReflectionInterface $reflectionElement): string
    {
        $doc = [];
        foreach (preg_split('~\\s*,\\s*~', $value) as $link) {
            if ($this->elementResolver->resolveElement($link, $reflectionElement) !== null) {
                $doc[] = $this->typeLinks($link, $reflectionElement);
            } else {
                $doc[] = $this->doc($link, $reflectionElement);
            }
        }

        return implode(', ', $doc);
    }

    private function processUsesAnnotations(string $value, ElementReflectionInterface $reflectionElement): ?string
    {
        [$link, $description] = Strings::split($value);

The variable $link does not exist. Did you forget to declare it?

The variable $description does not exist. Did you forget to declare it?

        $separator = $reflectionElement instanceof ClassReflectionInterface || ! $description ? ' ' : '<br>';
        if ($this->elementResolver->resolveElement($link, $reflectionElement) !== null) {
            $value = $this->typeLinks($link, $reflectionElement) . $separator . $description;
            return trim($value);
        }

        return null;
    }
}