ExtraPhpDocTagResolver::haveTag() - Code Metrics - Inspection of "refactor" - nazonohito51/dependency-analyzer - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 056350...65484c )

by Satoshi
created 2019-04-29 16:06 UTC
ExtraPhpDocTagResolver::haveTag() A

↳ Parent: ExtraPhpDocTagResolver
Complexity

Conditions	6
Paths	5
Size

Total Lines	19
Code Lines	10
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	6
eloc	10
nc	5
nop	2
dl	0
loc	19
rs	9.2222
c	0
b	0
f	0
<?php
declare(strict_types=1);

namespace DependencyAnalyzer\DependencyGraph;

use DependencyAnalyzer\DependencyDumper;
use DependencyAnalyzer\DependencyGraph\ExtraPhpDocTagResolver\DepsInternal;
use DependencyAnalyzer\DependencyGraph\FullyQualifiedStructuralElementName as FQSEN;
use DependencyAnalyzer\Exceptions\InvalidFullyQualifiedStructureElementNameException;
use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocTagNode;
use PHPStan\PhpDocParser\Lexer\Lexer;
use PHPStan\PhpDocParser\Parser\PhpDocParser;
use PHPStan\PhpDocParser\Parser\TokenIterator;
use PHPStan\Reflection\ClassReflection;

class ExtraPhpDocTagResolver
{
    const DEPS_INTERNAL = '@deps-internal';
    const ONLY_USED_BY_TAGS = '@canOnlyUsedBy';
    const DEPENDER_TAGS = '@dependee';
    const DEPENDEE_TAGS = '@dependee';

    /**
     * @var Lexer
     */
    protected $phpDocLexer;

    /**
     * @var PhpDocParser
     */
    protected $phpDocParser;

    public function __construct(Lexer $phpDocLexer, PhpDocParser $phpDocParser)
    {
        $this->phpDocLexer = $phpDocLexer;
        $this->phpDocParser = $phpDocParser;
    }

    public function collectExtraPhpDocs(\ReflectionClass $reflectionClass)
    {
//        $this->resolveInternalTag($reflectionClass);
        $this->resolveDepsInternalTag($reflectionClass);
//        $this->resolveUsesTag($reflectionClass);
    }

    /**
     * @param \ReflectionClass $reflectionClass
     * @return DepsInternal[]
     */
    public function resolveDepsInternalTag(\ReflectionClass $reflectionClass): array
    {
        $ret = [];

        if ($this->haveTag($reflectionClass, self::DEPS_INTERNAL)) {
            try {
                $ret[] = new DepsInternal(
                    FQSEN::createClass($reflectionClass->getName()),
                    $this->resolve($reflectionClass->getDocComment(), self::DEPS_INTERNAL)
                    $this->resolve(/** @scrutinizer ignore-type */ $reflectionClass->getDocComment(), self::DEPS_INTERNAL)
                );
            } catch (InvalidFullyQualifiedStructureElementNameException $e) {
                DependencyDumper::getObserver()->notifyResolvePhpDocError(
                    $reflectionClass->getFileName(),
                    FQSEN::createClass($reflectionClass->getName()),
                    /** @scrutinizer ignore-type */ FQSEN::createClass($reflectionClass->getName()),
                    $e
                );
            }
        }

        foreach ($reflectionClass->getProperties() as $reflectionProperty) {
            if ($this->haveTag($reflectionProperty, self::DEPS_INTERNAL)) {
                try {
                    $ret[] = new DepsInternal(
                        FQSEN::createProperty($reflectionClass->getName(), $reflectionProperty->getName()),
                        $this->resolve($reflectionProperty->getDocComment(), self::DEPS_INTERNAL)
                    );
                } catch (InvalidFullyQualifiedStructureElementNameException $e) {
                    DependencyDumper::getObserver()->notifyResolvePhpDocError(
                        $reflectionClass->getFileName(),
                        FQSEN::createClass($reflectionClass->getName()),
                        $e
                    );
                }
            }
        }

        foreach ($reflectionClass->getMethods() as $reflectionMethod) {
            if ($this->haveTag($reflectionMethod, self::DEPS_INTERNAL)) {
                try {
                    $ret[] = new DepsInternal(
                        FQSEN::createMethod($reflectionClass->getName(), $reflectionMethod->getName()),
                        $this->resolve($reflectionMethod->getDocComment(), self::DEPS_INTERNAL)
                    );
                } catch (InvalidFullyQualifiedStructureElementNameException $e) {
                    DependencyDumper::getObserver()->notifyResolvePhpDocError(
                        $reflectionClass->getFileName(),
                        FQSEN::createClass($reflectionClass->getName()),
                        $e
                    );
                }
            }
        }

        foreach ($reflectionClass->getReflectionConstants() as $reflectionClassConstant) {
            if ($this->haveTag($reflectionClassConstant, self::DEPS_INTERNAL)) {
                try {
                    $ret[] = new DepsInternal(
                        FQSEN::createClassConstant($reflectionClass->getName(), $reflectionClassConstant->getName()),
                        $this->resolve($reflectionClassConstant->getDocComment(), self::DEPS_INTERNAL)
                    );
                } catch (InvalidFullyQualifiedStructureElementNameException $e) {
                    DependencyDumper::getObserver()->notifyResolvePhpDocError(
                        $reflectionClass->getFileName(),
                        FQSEN::createClass($reflectionClass->getName()),
                        $e
                    );
                }
            }
        }

        return $ret;
    }

    protected function resolveInternalTag(\ReflectionClass $reflectionClass)
    {
        $phpDocs = [];

        $phpDocs[] = $reflectionClass->getDocComment();
        foreach ($reflectionClass->getProperties() as $reflectionProperty) {
            $phpDocs[] = $reflectionProperty->getDocComment();
        }
        foreach ($reflectionClass->getMethods() as $reflectionMethod) {
            $phpDocs[] = $reflectionMethod->getDocComment();
        }
        foreach ($reflectionClass->getReflectionConstants() as $reflectionClassConstant) {
            $phpDocs[] = $reflectionClassConstant->getDocComment();
        }


    }


    protected function resolveUsesTag(\ReflectionClass $reflectionClass)
    {
        $reflectionClass->getDocComment();
    }

    public function resolveCanOnlyUsedByTag(\ReflectionClass $classReflection): array
    {
        if ($phpdoc = $classReflection->getDocComment()) {
            return $this->resolve($phpdoc, self::ONLY_USED_BY_TAGS);
            return $this->resolve(/** @scrutinizer ignore-type */ $phpdoc, self::ONLY_USED_BY_TAGS);
        }

        return [];
//        $ret = [];
//        if ($phpdoc = $classReflection->getNativeReflection()->getDocComment()) {
//            $ret['class_must_have_special_chars_of_method'] = $this->resolve($phpdoc, self::ONLY_USED_BY_TAGS);
//        }
//
//        foreach ($classReflection->getNativeReflection()->getMethods() as $reflectionMethod) {
//            $phpdoc = $reflectionMethod->getDocComment();  // /**\n  * Hogefuga
//            $ret[$reflectionMethod->getName()] = $this->resolve($phpdoc, self::ONLY_USED_BY_TAGS);
//        }
//
//        return [];
    }

    /**
     * @param ClassReflection $classReflection
     * @return string[]
     */
    public function resolveDependerTag(ClassReflection $classReflection): array
    {
        if ($phpdoc = $classReflection->getNativeReflection()->getDocComment()) {
            return $this->resolve($phpdoc, self::DEPENDER_TAGS);
            return $this->resolve(/** @scrutinizer ignore-type */ $phpdoc, self::DEPENDER_TAGS);
        }

        return [];
    }

    /**
     * @param ClassReflection $classReflection
     * @return string[]
     */
    public function resolveDependeeTag(ClassReflection $classReflection): array
    {
        if ($phpdoc = $classReflection->getNativeReflection()->getDocComment()) {
            return $this->resolve($phpdoc, self::DEPENDEE_TAGS);
            return $this->resolve(/** @scrutinizer ignore-type */ $phpdoc, self::DEPENDEE_TAGS);
        }

        return [];
    }

    protected function haveTag(\Reflector $reflector, string $tag): bool
    {
        if (!method_exists($reflector, 'getDocComment') && $reflector->getDocComment() !== false) {
        if (!method_exists($reflector, 'getDocComment') && $reflector->/** @scrutinizer ignore-call */ getDocComment() !== false) {
            return false;
        } elseif (($docComment = $reflector->getDocComment()) === false) {

            return false;
    }

        $tokens = new TokenIterator($this->phpDocLexer->tokenize($reflector->getDocComment()));
        $phpDocNode = $this->phpDocParser->parse($tokens);

        foreach ($phpDocNode->getTagsByName($tag) as $phpDocTagNode) {
            /** @var PhpDocTagNode $phpDocTagNode */
            if (preg_match('/^' . $tag . '/', $phpDocTagNode->__toString()) === 1) {
                return true;
            }
        }

        return false;
    }

    protected function resolve(string $phpdoc, string $tag): array
    {
        $tokens = new TokenIterator($this->phpDocLexer->tokenize($phpdoc));
        $phpDocNode = $this->phpDocParser->parse($tokens);

        $ret = [];
        foreach ($phpDocNode->getTagsByName($tag) as $phpDocTagNode) {
            /** @var PhpDocTagNode $phpDocTagNode */
            if (preg_match('/^' . $tag . '\s+(.+)$/', $phpDocTagNode->__toString(), $matches) === 1) {
                $ret[] = $matches[1];
            }
        };

        return $ret;
    }
}

nazonohito51 / dependency-analyzer

Push — master ( 056350...65484c )

ExtraPhpDocTagResolver::haveTag() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
