UrlFilters - Code Metrics - Inspection of "Merge pull request #741 from POPSuL/issue/740" - apigen/ApiGen - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 4b6825...44404b )

by Jad

created 2016-09-07 12:56 UTC

UrlFilters B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	390
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	12

Importance

Changes	3
Bugs	0	Features	0

Metric	Value
c	3
b	0
f	0
dl	0
loc	390
rs	8.3206
wmc	51
lcom	1
cbo	12

20 Methods

Rating	Name	Size	Complexity
A	shortDescription()	4	1
A	__construct()	15	1
A	annotation()	18	2
B	typeLinks()	16	5
A	description()	5	2
A	longDescription()	13	2
A	doc()	13	2
A	resolveInternalAnnotation()	15	4
A	resolveLinkAndSeeAnnotation()	16	4
A	highlightPhp()	5	2
A	highlightValue()	4	1
A	createLinkForElement()	4	1
A	processReturnAnnotations()	6	1
A	processLicenseAnnotations()	5	2
A	processLinkAnnotations()	8	3
A	processSeeAnnotations()	12	3
C	resolveLink()	30	7
A	processThrowsAnnotations()	6	1
A	getDescriptionFromValue()	8	3
A	processUsesAndUsedbyAnnotations()	10	4

How to fix Complexity

<?php

/**
 * This file is part of the ApiGen (http://apigen.org)
 *
 * For the full copyright and license information, please view
 * the file LICENSE that was distributed with this source code.
 */

namespace ApiGen\Templating\Filters;

use ApiGen\Configuration\Configuration;
use ApiGen\Configuration\ConfigurationOptions as CO;
use ApiGen\Contracts\Generator\Resolvers\ElementResolverInterface;
use ApiGen\Contracts\Parser\Reflection\ClassReflectionInterface;
use ApiGen\Contracts\Parser\Reflection\ElementReflectionInterface;
use ApiGen\Contracts\Parser\Reflection\FunctionReflectionInterface;
use ApiGen\Generator\Markups\Markup;
use ApiGen\Generator\SourceCodeHighlighter\SourceCodeHighlighter;
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;

class UrlFilters extends Filters
{

    /**
     * @var SourceCodeHighlighter
     */
    private $highlighter;

    /**
     * @var Markup
     */
    private $markup;

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

    /**
     * @var Configuration
     */
    private $configuration;

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

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


    public function __construct(
        Configuration $configuration,
        SourceCodeHighlighter $highlighter,
        Markup $markup,
        ElementResolverInterface $elementResolver,
        LinkBuilder $linkBuilder,
        ElementLinkFactory $elementLinkFactory
    ) {
        $this->highlighter = $highlighter;
        $this->markup = $markup;
        $this->elementResolver = $elementResolver;
        $this->configuration = $configuration;
        $this->linkBuilder = $linkBuilder;
        $this->elementLinkFactory = $elementLinkFactory;
    }


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

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

        $element = $this->elementResolver->resolveElement($definition, $reflectionElement, $expectedName);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        if ($element === null || $element instanceof FunctionReflectionInterface) {
            return $expectedName;
        }

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

        /** @var FunctionReflectionInterface $element */
        if (! $element->isValid()) {
            $classes[] = 'invalid';
        }

        $link = $this->createLinkForElement($element, $classes);
        return '<code>' . $link . $suffix . '</code>';
    }


    /**
     * @param string $value
     * @param string $name
     * @param ElementReflectionInterface $reflectionElement
     * @return string
     */
    public function annotation($value, $name, ElementReflectionInterface $reflectionElement)
    {
        $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->processUsesAndUsedbyAnnotations($value, $reflectionElement),
            'usedby' => $this->processUsesAndUsedbyAnnotations($value, $reflectionElement),
        ];

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

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


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

        list($types) = Strings::split($annotation);
        if (! empty($types) && $types[0] === '$') {
            $types = null;
        }

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

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


    /********************* description *********************/


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


    /**
     * @param ElementReflectionInterface $reflectionElement
     * @param bool $block
     * @return string
     */
    public function shortDescription(ElementReflectionInterface $reflectionElement, $block = false)
    {
        return $this->doc($reflectionElement->getShortDescription(), $reflectionElement, $block);
    }


    /**
     * @return string
     */
    public function longDescription(ElementReflectionInterface $element)
    {
        $long = $element->getLongDescription();

        // 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, true);
    }


    /********************* text formatter *********************/


    /**
     * @param string $text
     * @param ElementReflectionInterface $reflectionElement
     * @param bool $block
     * @return string
     */
    public function doc($text, ElementReflectionInterface $reflectionElement, $block = false)
    {
        $text = $this->resolveInternalAnnotation($text);

        // Process markup
        if ($block) {
            $text = $this->markup->block($text);
        } else {
            $text = $this->markup->line($text);
        }

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


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

            if ($this->configuration->getOption(CO::INTERNAL) && isset($matches[2])) {
                return $matches[2];
            }

            return '';
        }, $text);
    }


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

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

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

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


    /********************* highlight *********************/


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


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


    /**
     * @return string
     */
    private function createLinkForElement($reflectionElement, array $classes)
    {
        return $this->elementLinkFactory->createForElement($reflectionElement, $classes);
    }


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


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


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

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $description = '<br>' . $this->doc($description, $elementReflection);
        }
        return $description;
    }


    /**
     * @param string $value
     * @return string
     */
    private function processLicenseAnnotations($value)
    {
        list($url, $description) = Strings::split($value);
        return $this->linkBuilder->build($url, $description ?: $url);
    }


    /**
     * @param string $value
     * @return string
     */
    private function processLinkAnnotations($value)
    {
        list($url, $description) = Strings::split($value);
        if (Validators::isUrl($url)) {
            return $this->linkBuilder->build($url, $description ?: $url);
        }
        return null;
    }


    /**
     * @param string $value
     * @param ElementReflectionInterface $reflectionElement
     * @return string
     */
    private function processSeeAnnotations($value, ElementReflectionInterface $reflectionElement)
    {
        $doc = [];
        foreach (preg_split('~\\s*,\\s*~', $value) as $link) {
            if ($this->elementResolver->resolveElement($link, $reflectionElement) !== null) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                $doc[] = $this->typeLinks($link, $reflectionElement);
            } else {
                $doc[] = $this->doc($link, $reflectionElement);
            }
        }
        return implode(', ', $doc);
    }


    /**
     * @param string $value
     * @param ElementReflectionInterface $reflectionElement
     * @return string
     */
    private function processUsesAndUsedbyAnnotations($value, ElementReflectionInterface $reflectionElement)
    {
        list($link, $description) = Strings::split($value);
        $separator = $reflectionElement instanceof ClassReflectionInterface || ! $description ? ' ' : '<br>';
        if ($this->elementResolver->resolveElement($link, $reflectionElement) !== null) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $value = $this->typeLinks($link, $reflectionElement) . $separator . $description;
            return trim($value);
        }
        return null;
    }
}


GitHub Access Token became invalid

Push — master ( 4b6825...44404b )

UrlFilters B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

20 Methods

How to fix Complexity

Complex Class

1			<?php
2
3			/**
4			* This file is part of the ApiGen (http://apigen.org)
5			*
6			* For the full copyright and license information, please view
7			* the file LICENSE that was distributed with this source code.
8			*/
9
10			namespace ApiGen\Templating\Filters;
11
12			use ApiGen\Configuration\Configuration;
13			use ApiGen\Configuration\ConfigurationOptions as CO;
14			use ApiGen\Contracts\Generator\Resolvers\ElementResolverInterface;
15			use ApiGen\Contracts\Parser\Reflection\ClassReflectionInterface;
16			use ApiGen\Contracts\Parser\Reflection\ElementReflectionInterface;
17			use ApiGen\Contracts\Parser\Reflection\FunctionReflectionInterface;
18			use ApiGen\Generator\Markups\Markup;
19			use ApiGen\Generator\SourceCodeHighlighter\SourceCodeHighlighter;
20			use ApiGen\Templating\Filters\Helpers\ElementLinkFactory;
21			use ApiGen\Templating\Filters\Helpers\LinkBuilder;
22			use ApiGen\Templating\Filters\Helpers\Strings;
23			use Latte\Runtime\Filters as LatteFilters;
24			use Nette\Utils\Validators;
25
26			class UrlFilters extends Filters
27			{
28
29			/**
30			* @var SourceCodeHighlighter
31			*/
32			private $highlighter;
33
34			/**
35			* @var Markup
36			*/
37			private $markup;
38
39			/**
40			* @var ElementResolverInterface
41			*/
42			private $elementResolver;
43
44			/**
45			* @var Configuration
46			*/
47			private $configuration;
48
49			/**
50			* @var LinkBuilder
51			*/
52			private $linkBuilder;
53
54			/**
55			* @var ElementLinkFactory
56			*/
57			private $elementLinkFactory;
58
59
60			public function __construct(
61			Configuration $configuration,
62			SourceCodeHighlighter $highlighter,
63			Markup $markup,
64			ElementResolverInterface $elementResolver,
65			LinkBuilder $linkBuilder,
66			ElementLinkFactory $elementLinkFactory
67			) {
68			$this->highlighter = $highlighter;
69			$this->markup = $markup;
70			$this->elementResolver = $elementResolver;
71			$this->configuration = $configuration;
72			$this->linkBuilder = $linkBuilder;
73			$this->elementLinkFactory = $elementLinkFactory;
74			}
75
76
77			/**
78			* Tries to parse a definition of a class/method/property/constant/function
79			* and returns the appropriate link if successful.
80			*
81			* @param string $definition
82			* @param ElementReflectionInterface $reflectionElement
83			* @return string\|NULL
84			*/
85			public function resolveLink($definition, ElementReflectionInterface $reflectionElement)
86			{
87			if (empty($definition)) {
88			return null;
89			}
90
91			$suffix = '';
92			if (substr($definition, -2) === '[]') {
93			$definition = substr($definition, 0, -2);
94			$suffix = '[]';
95			}
96
97			$element = $this->elementResolver->resolveElement($definition, $reflectionElement, $expectedName);
			0 ignored issues – show Documentation introduced 2015-12-14 11:55 UTC by Report Bug Copy Issue Report `$reflectionElement` is of type `object<ApiGen\Contracts\...entReflectionInterface>`, but the function expects a `string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
98			if ($element === null \|\| $element instanceof FunctionReflectionInterface) {
99			return $expectedName;
100			}
101
102			$classes = [];
103			if ($element->isDeprecated()) {
104			$classes[] = 'deprecated';
105			}
106
107			/** @var FunctionReflectionInterface $element */
108			if (! $element->isValid()) {
109			$classes[] = 'invalid';
110			}
111
112			$link = $this->createLinkForElement($element, $classes);
113			return '<code>' . $link . $suffix . '</code>';
114			}
115
116
117			/**
118			* @param string $value
119			* @param string $name
120			* @param ElementReflectionInterface $reflectionElement
121			* @return string
122			*/
123			public function annotation($value, $name, ElementReflectionInterface $reflectionElement)
124			{
125			$annotationProcessors = [
126			'return' => $this->processReturnAnnotations($value, $reflectionElement),
127			'throws' => $this->processThrowsAnnotations($value, $reflectionElement),
128			'license' => $this->processLicenseAnnotations($value),
129			'link' => $this->processLinkAnnotations($value),
130			'see' => $this->processSeeAnnotations($value, $reflectionElement),
131			'uses' => $this->processUsesAndUsedbyAnnotations($value, $reflectionElement),
132			'usedby' => $this->processUsesAndUsedbyAnnotations($value, $reflectionElement),
133			];
134
135			if (isset($annotationProcessors[$name])) {
136			return $annotationProcessors[$name];
137			}
138
139			return $this->doc($value, $reflectionElement);
140			}
141
142
143			/**
144			* Returns links for types.
145			*
146			* @param string $annotation
147			* @param ElementReflectionInterface $reflectionElement
148			* @return string
149			*/
150			public function typeLinks($annotation, ElementReflectionInterface $reflectionElement)
151			{
152			$links = [];
153
154			list($types) = Strings::split($annotation);
155			if (! empty($types) && $types[0] === '$') {
156			$types = null;
157			}
158
159			foreach (explode('\|', $types) as $type) {
160			$type = $this->getTypeName($type, false);
161			$links[] = $this->resolveLink($type, $reflectionElement) ?: LatteFilters::escapeHtml(ltrim($type, '\\'));
162			}
163
164			return implode('\|', $links);
165			}
166
167
168			/******************* description *******************/
169
170
171			/**
172			* @param string $annotation
173			* @param ElementReflectionInterface $reflectionElement
174			* @return string
175			*/
176			public function description($annotation, ElementReflectionInterface $reflectionElement)
177			{
178			$description = trim(strpbrk($annotation, "\n\r\t $")) ?: $annotation;
179			return $this->doc($description, $reflectionElement);
180			}
181
182
183			/**
184			* @param ElementReflectionInterface $reflectionElement
185			* @param bool $block
186			* @return string
187			*/
188			public function shortDescription(ElementReflectionInterface $reflectionElement, $block = false)
189			{
190			return $this->doc($reflectionElement->getShortDescription(), $reflectionElement, $block);
191			}
192
193
194			/**
195			* @return string
196			*/
197			public function longDescription(ElementReflectionInterface $element)
198			{
199			$long = $element->getLongDescription();
200
201			// Merge lines
202			$long = preg_replace_callback('~(?:<(code\|pre)>.+?</\1>)\|([^<]*)~s', function ($matches) {
203			return ! empty($matches[2])
204			? preg_replace('~\n(?:(\s+\n){2,})+~', ' ', $matches[2])
205			: $matches[0];
206			}, $long);
207
208			return $this->doc($long, $element, true);
209			}
210
211
212			/******************* text formatter *******************/
213
214
215			/**
216			* @param string $text
217			* @param ElementReflectionInterface $reflectionElement
218			* @param bool $block
219			* @return string
220			*/
221			public function doc($text, ElementReflectionInterface $reflectionElement, $block = false)
222			{
223			$text = $this->resolveInternalAnnotation($text);
224
225			// Process markup
226			if ($block) {
227			$text = $this->markup->block($text);
228			} else {
229			$text = $this->markup->line($text);
230			}
231
232			return $this->resolveLinkAndSeeAnnotation($text, $reflectionElement);
233			}
234
235
236			/**
237			* @param string $text
238			* @return string
239			*/
240			private function resolveInternalAnnotation($text)
241			{
242			$pattern = '~\\{@(\\w+)(?:(?:\\s+((?>(?R)\|[^{}]+)*)\\})\|\\})~';
243			return preg_replace_callback($pattern, function ($matches) {
244			if ($matches[1] !== 'internal') {
245			return $matches[0];
246			}
247
248			if ($this->configuration->getOption(CO::INTERNAL) && isset($matches[2])) {
249			return $matches[2];
250			}
251
252			return '';
253			}, $text);
254			}
255
256
257			/**
258			* @param string $text
259			* @param ElementReflectionInterface $reflectionElement
260			* @return string
261			*/
262			private function resolveLinkAndSeeAnnotation($text, ElementReflectionInterface $reflectionElement)
263			{
264			return preg_replace_callback('~{@(?:link\|see)\\s+([^}]+)}~', function ($matches) use ($reflectionElement) {
265			list($url, $description) = Strings::split($matches[1]);
266
267			if (Validators::isUri($url)) {
268			return $this->linkBuilder->build($url, $description ?: $url);
269			}
270
271			if ($link = $this->resolveLink($matches[1], $reflectionElement)) {
272			return $link;
273			}
274
275			return $matches[1];
276			}, $text);
277			}
278
279
280			/******************* highlight *******************/
281
282
283			/**
284			* @param string $source
285			* @param ElementReflectionInterface $reflectionElement
286			* @return string
287			*/
288			public function highlightPhp($source, ElementReflectionInterface $reflectionElement)
289			{
290			return $this->resolveLink($this->getTypeName($source), $reflectionElement)
291			?: $this->highlighter->highlight((string) $source);
292			}
293
294
295			/**
296			* @param string $definition
297			* @param ElementReflectionInterface $reflectionElement
298			* @return string
299			*/
300			public function highlightValue($definition, ElementReflectionInterface $reflectionElement)
301			{
302			return $this->highlightPhp(preg_replace('~^(?:[ ]{4}\|\t)~m', '', $definition), $reflectionElement);
303			}
304
305
306			/**
307			* @return string
308			*/
309			private function createLinkForElement($reflectionElement, array $classes)
310			{
311			return $this->elementLinkFactory->createForElement($reflectionElement, $classes);
312			}
313
314
315			/**
316			* @param string $value
317			* @param ElementReflectionInterface $reflectionElement
318			* @return string
319			*/
320			private function processReturnAnnotations($value, ElementReflectionInterface $reflectionElement)
321			{
322			$description = $this->getDescriptionFromValue($value, $reflectionElement);
323			$typeLinks = $this->typeLinks($value, $reflectionElement);
324			return $typeLinks . $description;
325			}
326
327
328			/**
329			* @param string $value
330			* @param ElementReflectionInterface $elementReflection
331			* @return string
332			*/
333			private function processThrowsAnnotations($value, ElementReflectionInterface $elementReflection)
334			{
335			$description = $this->getDescriptionFromValue($value, $elementReflection);
336			$typeLinks = $this->typeLinks($value, $elementReflection);
337			return $typeLinks . $description;
338			}
339
340
341			/**
342			* @param mixed $value
343			* @param ElementReflectionInterface $elementReflection
344			* @return string
345			*/
346			private function getDescriptionFromValue($value, ElementReflectionInterface $elementReflection)
347			{
348			$description = trim(strpbrk($value, "\n\r\t $")) ?: null;
349			if ($description) {
			0 ignored issues – show Bug Best Practice introduced 2015-11-29 18:26 UTC by Report Bug Copy Issue Report 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. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
350			$description = '<br>' . $this->doc($description, $elementReflection);
351			}
352			return $description;
353			}
354
355
356			/**
357			* @param string $value
358			* @return string
359			*/
360			private function processLicenseAnnotations($value)
361			{
362			list($url, $description) = Strings::split($value);
363			return $this->linkBuilder->build($url, $description ?: $url);
364			}
365
366
367			/**
368			* @param string $value
369			* @return string
370			*/
371			private function processLinkAnnotations($value)
372			{
373			list($url, $description) = Strings::split($value);
374			if (Validators::isUrl($url)) {
375			return $this->linkBuilder->build($url, $description ?: $url);
376			}
377			return null;
378			}
379
380
381			/**
382			* @param string $value
383			* @param ElementReflectionInterface $reflectionElement
384			* @return string
385			*/
386			private function processSeeAnnotations($value, ElementReflectionInterface $reflectionElement)
387			{
388			$doc = [];
389			foreach (preg_split('~\\s,\\s~', $value) as $link) {
390			if ($this->elementResolver->resolveElement($link, $reflectionElement) !== null) {
			0 ignored issues – show Documentation introduced 2016-08-25 17:50 UTC by Report Bug Copy Issue Report `$reflectionElement` is of type `object<ApiGen\Contracts\...entReflectionInterface>`, but the function expects a `string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
391			$doc[] = $this->typeLinks($link, $reflectionElement);
392			} else {
393			$doc[] = $this->doc($link, $reflectionElement);
394			}
395			}
396			return implode(', ', $doc);
397			}
398
399
400			/**
401			* @param string $value
402			* @param ElementReflectionInterface $reflectionElement
403			* @return string
404			*/
405			private function processUsesAndUsedbyAnnotations($value, ElementReflectionInterface $reflectionElement)
406			{
407			list($link, $description) = Strings::split($value);
408			$separator = $reflectionElement instanceof ClassReflectionInterface \|\| ! $description ? ' ' : '<br>';
409			if ($this->elementResolver->resolveElement($link, $reflectionElement) !== null) {
			0 ignored issues – show Documentation introduced 2016-08-25 17:50 UTC by Report Bug Copy Issue Report `$reflectionElement` is of type `object<ApiGen\Contracts\...entReflectionInterface>`, but the function expects a `string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
410			$value = $this->typeLinks($link, $reflectionElement) . $separator . $description;
411			return trim($value);
412			}
413			return null;
414			}
415			}
416

apigen / ApiGen

GitHub Access Token became invalid

Push — master ( 4b6825...44404b )

UrlFilters B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

20 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like