Ray\Aop\CodeGen

Complexity

Total Complexity

12

Size/Duplication

Total Lines	201
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	12

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	getClassAnnotation()	0	6	1
A	__construct()	0	11	1
A	generate()	0	13	1
A	getUseStatements()	0	14	1
A	getClass()	0	12	1
A	addClassDocComment()	0	9	2
A	addInterceptorProp()	0	14	1
A	addSerialisedAnnotationProp()	0	16	1
A	getMethodAnnotations()	0	14	3

<?php
/**
 * This file is part of the Ray.Aop package
 *
 * @license http://opensource.org/licenses/MIT MIT
 */
namespace Ray\Aop;

use Doctrine\Common\Annotations\AnnotationReader;
use Doctrine\Common\Annotations\IndexedReader;
use PhpParser\Builder\Class_ as Builder;
use PhpParser\BuilderFactory;
use PhpParser\Comment\Doc;
use PhpParser\Node\Stmt\Class_;
use PhpParser\NodeTraverser;
use PhpParser\Parser;
use PhpParser\PrettyPrinter\Standard;

final class CodeGen implements CodeGenInterface
{
    /**
     * @var \PhpParser\Parser
     */
    private $parser;

    /**
     * @var \PhpParser\BuilderFactory
     */
    private $factory;

    /**
     * @var \PhpParser\PrettyPrinter\Standard
     */
    private $printer;

    /**
     * @var CodeGenMethod
     */
    private $codeGenMethod;

    /**
     * @var IndexedReader
     */
    private $reader;

    /**
     * @param \PhpParser\Parser                 $parser
     * @param \PhpParser\BuilderFactory         $factory
     * @param \PhpParser\PrettyPrinter\Standard $printer
     */
    public function __construct(
        Parser $parser,
        BuilderFactory $factory,
        Standard $printer
    ) {
        $this->parser = $parser;
        $this->factory = $factory;
        $this->printer = $printer;
        $this->codeGenMethod = new CodeGenMethod($parser, $factory, $printer);
        $this->reader = new IndexedReader(new AnnotationReader);
    }

    /**
     * @param string           $class
     * @param \ReflectionClass $sourceClass
     * @param BindInterface    $bind
     *
     * @return string
     */
    public function generate($class, \ReflectionClass $sourceClass, BindInterface $bind)
    {
        $methods = $this->codeGenMethod->getMethods($sourceClass, $bind);
        $stmt = $this
            ->getClass($class, $sourceClass)
            ->addStmts($methods)
            ->getNode();
        $stmt = $this->addClassDocComment($stmt, $sourceClass);
        $code = $this->printer->prettyPrint([$stmt]);
        $statements = $this->getUseStatements($sourceClass);

        return $statements . $code;
    }

    /**
     * @param \ReflectionClass $class
     *
     * @return string
     */
    private function getUseStatements(\ReflectionClass $class)
    {
        $traverser = new NodeTraverser();
        $useStmtsVisitor = new CodeGenVisitor();
        $traverser->addVisitor($useStmtsVisitor);
        // parse
        $stmts = $this->parser->parse(file_get_contents($class->getFileName()));
        // traverse
        $traverser->traverse($stmts);

It seems like $stmts defined by $this->parser->parse(file_get_contents($class->getFileName())) on line 95 can also be of type null; however, PhpParser\NodeTraverser::traverse() does only seem to accept array<integer,object<PhpParser\Node>>, maybe add an additional type check?

        // pretty print
        $code = $this->printer->prettyPrint($useStmtsVisitor());

        return (string) $code;
    }

    /**
     * Return class statement
     *
     * @param string           $newClassName
     * @param \ReflectionClass $class
     *
     * @return \PhpParser\Builder\Class_
     */
    private function getClass($newClassName, \ReflectionClass $class)
    {
        $parentClass = $class->name;
        $builder = $this->factory
            ->class($newClassName)
            ->extend($parentClass)
            ->implement('Ray\Aop\WeavedInterface');
        $builder = $this->addInterceptorProp($builder);
        $builder = $this->addSerialisedAnnotationProp($builder, $class);

        return $builder;
    }

    /**
     * Add class doc comment
     *
     * @param Class_           $node
     * @param \ReflectionClass $class
     *
     * @return \PhpParser\Node\Stmt\Class_
     */
    private function addClassDocComment(Class_ $node, \ReflectionClass $class)
    {
        $docComment = $class->getDocComment();
        if ($docComment) {
            $node->setAttribute('comments', [new Doc($docComment)]);
        }

        return $node;
    }

    /**
     * @param \ReflectionClass $class
     *
     * @return string
     */
    private function getClassAnnotation(\ReflectionClass $class)
    {
        $classAnnotations = $this->reader->getClassAnnotations($class);

        return serialize($classAnnotations);
    }

    /**
     * @param Builder $builder
     *
     * @return Builder
     */
    private function addInterceptorProp(Builder $builder)
    {
        $builder->addStmt(
            $this->factory
                ->property('isIntercepting')
                ->makePrivate()
                ->setDefault(true)
        )->addStmt(
            $this->factory->property('bind')
            ->makePublic()
        );

        return $builder;
    }

    /**
     * Add serialised
     *
     * @param Builder          $builder
     * @param \ReflectionClass $class
     *
     * @return Builder
     */
    private function addSerialisedAnnotationProp(Builder $builder, \ReflectionClass $class)
    {
        $builder->addStmt(
            $this->factory
                ->property('methodAnnotations')
                ->setDefault($this->getMethodAnnotations($class))
                ->makePublic()
        )->addStmt(
            $this->factory
                ->property('classAnnotations')
                ->setDefault($this->getClassAnnotation($class))
                ->makePublic()
        );

        return $builder;
    }

    /**
     * @param \ReflectionClass $class
     *
     * @return string
     */
    private function getMethodAnnotations(\ReflectionClass $class)
    {
        $methodsAnnotation = [];
        $methods = $class->getMethods();
        foreach ($methods as $method) {
            $annotations = $this->reader->getMethodAnnotations($method);
            if ($annotations === []) {
                continue;
            }
            $methodsAnnotation[$method->getName()] = $annotations;

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

        }

        return serialize($methodsAnnotation);
    }
}