PhpBoot\Annotation\AnnotationReader

Complexity

Total Complexity

27

Size/Duplication

Total Lines	157
Duplicated Lines	10.19 %

Coupling/Cohesion

Components	1
Dependencies	12

Test Coverage

Coverage

86.14%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	assertAnnotationEnabled()	0	5	2
A	createDocBlockFactory()	0	9	1
C	read()	0	24	8
B	readAnnotationBlock()	0	34	5
A	offsetExists()	0	4	1
A	offsetGet()	0	4	1
A	offsetSet()	0	4	1
A	offsetUnset()	0	4	1
C	readWithoutCache()	16	35	7

<?php

namespace PhpBoot\Annotation;
use Doctrine\Common\Cache\ApcCache;
use Doctrine\Common\Cache\Cache;
use PhpBoot\Cache\CheckableCache;
use PhpBoot\Cache\ClassModifiedChecker;
use phpDocumentor\Reflection\DocBlock\DescriptionFactory;
use phpDocumentor\Reflection\DocBlock\StandardTagFactory;
use phpDocumentor\Reflection\DocBlock\Tag;
use phpDocumentor\Reflection\DocBlock\Tags\Formatter;
use phpDocumentor\Reflection\DocBlockFactory;
use phpDocumentor\Reflection\FqsenResolver;
use phpDocumentor\Reflection\TypeResolver;

/**
 * AnnotationEnabledTest
 */
class AnnotationEnabledTest
{
    /**
     * testMethod
     */
    public function testMethod()
    {

    }
}

class AnnotationTagsOutput implements Formatter

PSR1 recommends that each class should be in its own file to aid autoloaders.

{
    /**
     * Formats a tag into a string representation according to a specific format, such as Markdown.
     *
     * @param Tag $tag
     *
     * @return string
     */
    public function format(Tag $tag)
    {
        $this->tags[] = $tag;
        return strval($tag);
    }
    public $tags = [];
}
class AnnotationReader implements \ArrayAccess

PSR1 recommends that each class should be in its own file to aid autoloaders.

{
    static public function createDocBlockFactory(){

As per PSR2, the static declaration should come after the visibility declaration.

        $fqsenResolver = new FqsenResolver();
        $tagFactory = new StandardTagFactory($fqsenResolver,[]);
        $descriptionFactory = new DescriptionFactory($tagFactory);
        $tagFactory->addService($descriptionFactory);
        $tagFactory->addService(new TypeResolver($fqsenResolver));
        $docBlockFactory = new DocBlockFactory($descriptionFactory, $tagFactory);
        return $docBlockFactory;
    }

    static public function assertAnnotationEnabled()

As per PSR2, the static declaration should come after the visibility declaration.

    {
        $rfl = new \ReflectionClass(AnnotationEnabledTest::class);
        !empty($rfl->getDocComment()) or \PhpBoot\abort('Annotation dose not work! If opcache is enable, please set opcache.save_comments=1 and opcache.load_comments=1');

Using logical operators such as or instead of || is generally not recommended.

    }
    /**
     * load from class with local cache
     * TODO 增加 filter 能力
     * @param string $className
     * @param Cache $localCache
     * @return object
     */
    static public function read($className, Cache $localCache = null)

As per PSR2, the static declaration should come after the visibility declaration.

    {
        self::assertAnnotationEnabled();
        $rfl = new \ReflectionClass($className) or \PhpBoot\abort("load class $className failed");

Using logical operators such as or instead of || is generally not recommended.

        $fileName = $rfl->getFileName();
        $key = str_replace('\\','.',self::class).md5($fileName.$className);
        $oldData = null;
        $cache = new CheckableCache($localCache?:new ApcCache());

The class Doctrine\Common\Cache\ApcCache has been deprecated with message: since version 1.6, use ApcuCache instead

        $res = $cache->get('ann:'.$key, null, $oldData, false);
        if($res === null){
            try{
                $meta = self::readWithoutCache($className);
                $cache->set($key, $meta, 0, $fileName?new ClassModifiedChecker($className):null);
                return $meta;
            }catch (\Exception $e){
                $cache->set($key, $e->getMessage(), 0, $fileName?new ClassModifiedChecker($className):null);
                throw $e;
            }
        }elseif(is_string($res)){
            \PhpBoot\abort($res);
        }else{
            return $res;
        }
    }
    /**
     * @param $className
     * @return self
     */
    static function readWithoutCache($className)
    {
        $reader = new self();

        $rfl = new \ReflectionClass($className);
        $reader->class = self::readAnnotationBlock($rfl->getDocComment());
        $reader->class->name = $className;

        //method annotations
        foreach ($rfl->getMethods() as $i){
            $block = self::readAnnotationBlock($i->getDocComment());
            $block->name = $i->getName();

Consider using $i->name. There is an issue with getName() and APC-enabled PHP versions.

            $reader->methods[$i->getName()]=$block;

Consider using $i->name. There is an issue with getName() and APC-enabled PHP versions.

        }
        //property annotations
        foreach ($rfl->getProperties() as $i){

This code seems to be duplicated across your project.

            if ($i->isStatic()) {
                continue;
            }
            $block = self::readAnnotationBlock($i->getDocComment());
            $block->name = $i->getName();
            $reader->properties[$i->getName()]=$block;
        }
        while ($rfl = $rfl->getParentClass()) {
            foreach ($rfl->getProperties(\ReflectionProperty::IS_PRIVATE) as $i) {

This code seems to be duplicated across your project.

                if ($i->isStatic()) {
                    continue;
                }
                $block = self::readAnnotationBlock($i->getDocComment());
                $block->name = $i->getName();
                $reader->properties[$i->getName()]=$block;
            }
        }
        return $reader;
    }

    static private function readAnnotationBlock($doc)

As per PSR2, the static declaration should come after the visibility declaration.

    {
        $annBlock = new AnnotationBlock();
        if(empty($doc)){
            return $annBlock;
        }
        $docFactory = AnnotationReader::createDocBlockFactory();
        $docBlock = $docFactory->create($doc);
        $annBlock->summary = $docBlock->getSummary();
        $annBlock->description = strval($docBlock->getDescription());
        $annBlock->children = [];
        $tags = $docBlock->getTags();
        foreach ($tags as $tag) {
            $annTag = new AnnotationTag();
            $desc = $tag->getDescription();
            $annTag->parent = $annBlock;
            $annTag->description = strval($desc);
            $annTag->name = $tag->getName();
            $annTag->children=[];
            if($desc){
                $output = new AnnotationTagsOutput();
                $desc->render($output);
                foreach ($output->tags as $child) {
                    $childTag = new AnnotationTag();
                    $childTag->parent = $annTag;

It seems like $annTag of type object<PhpBoot\Annotation\AnnotationTag> is incompatible with the declared type object<PhpBoot\Annotation\AnnotationBlock>|null of property $parent.

                    $childTag->name = $child->getName();
                    $childTag->description = strval($child->getDescription());
                    $annTag->children[] = $childTag;
                }
            }
            $annBlock->children[] = $annTag;
        }
        return $annBlock;
    }

    /**
     * @var AnnotationBlock
     */
    public $class;
    /**
     * @var AnnotationBlock[]
     */

    public $methods=[];
    /**
     * @var AnnotationBlock[]
     */
    public $properties=[];

    public function offsetExists($offset)
    {
        return isset($this->$offset);
    }

    public function offsetGet($offset)
    {
        return $this->$offset;
    }

    public function offsetSet($offset, $value)
    {
        $this->$offset = $value;
    }

    public function offsetUnset($offset)
    {
        unset($this->$offset);
    }
}