WyriHaximus\React\Cake\Orm\AsyncTableGenerator

Complexity

Total Complexity

25

Size/Duplication

Total Lines	224
Duplicated Lines	12.5 %

Coupling/Cohesion

Components	1
Dependencies	20

Test Coverage

Coverage

94.51%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	locateClassloader()	0	13	3
B	generate()	0	68	4
A	createMethod()	0	21	1
A	createMethodArguments()	0	11	3
A	extractMethods()	12	12	4
B	iterageStmts()	16	16	5
A	extractNamespace()	0	10	3
A	hasMethodAnnotation()	0	5	1

<?php

namespace WyriHaximus\React\Cake\Orm;

use BetterReflection\Reflection\ReflectionClass;
use Cake\Datasource\EntityInterface;
use Composer\Autoload\ClassLoader;
use Doctrine\Common\Annotations\AnnotationReader;
use Generator;
use PhpParser\BuilderFactory;
use PhpParser\Node;
use PhpParser\Parser;
use PhpParser\ParserFactory;
use PhpParser\PrettyPrinter\Standard;
use RuntimeException;
use WyriHaximus\React\Cake\Orm\Annotations\Ignore;

final class AsyncTableGenerator
{
    const NAMESPACE_PREFIX = 'WyriHaximus\GeneratedAsyncCakeTable\\';

    /**
     * @var string
     */
    private $storageLocation;

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

    /**
     * @var Parser
     */
    private $parser;

    /**
     * @var ClassLoader
     */
    private $classLoader;

    /**
     * @var AnnotationReader
     */
    private $annotationReader;

    /**
     * @param string $storageLocation
     */
    public function __construct($storageLocation)
    {
        $this->storageLocation = $storageLocation;
        $this->factory = new BuilderFactory();
        $this->parser = (new ParserFactory)->create(ParserFactory::PREFER_PHP7);
        $this->classLoader = $this->locateClassloader();
        $this->annotationReader = new AnnotationReader();
    }

    private function locateClassloader()
    {
        foreach ([
            dirname(__DIR__) . DS . 'vendor' . DS . 'autoload.php',
            dirname(dirname(dirname(__DIR__))) . DS . 'autoload.php',
        ] as $path) {
            if (file_exists($path)) {
                return require $path;
            }
        }

        throw new RuntimeException('Unable to locate class loader');
    }

    /**
     * @param $tableClass
     * @return GeneratedTable
     */
    public function generate($tableClass)
    {
        $fileName = $this->classLoader->findFile($tableClass);
        $contents = file_get_contents($fileName);
        $ast = $this->parser->parse($contents);
        $namespace = static::NAMESPACE_PREFIX . $this->extractNamespace($ast);

It seems like $ast defined by $this->parser->parse($contents) on line 81 can also be of type null; however, WyriHaximus\React\Cake\Orm\AsyncTableGenerator::extractNamespace() does only seem to accept array, maybe add an additional type check?

        $hashedClass = 'C' . md5($tableClass) . '_F' . md5($contents);

        $generatedTable = new GeneratedTable($namespace, $hashedClass);

        if (file_exists($this->storageLocation . DIRECTORY_SEPARATOR . $hashedClass . '.php')) {
            return $generatedTable;
        }

        $class = $this->factory->class($hashedClass)
            ->extend('BaseTable')
            ->implement('AsyncTableInterface')
        ;

        $class->addStmt(
            new Node\Stmt\TraitUse([
                new Node\Name('AsyncTable')
            ])
        );

        $class->addStmt(
            self::createMethod(
                'save',
                [
                    new Node\Param('entity', null, 'EntityInterface'),
                    new Node\Param('options', new Node\Expr\Array_()),
                ]
            )
        );

        foreach ($this->extractMethods($ast) as $method) {

It seems like $ast defined by $this->parser->parse($contents) on line 81 can also be of type null; however, WyriHaximus\React\Cake\Orm\AsyncTableGenerator::extractMethods() does only seem to accept array<integer,object<PhpParser\Node>>, maybe add an additional type check?

            if (!$this->hasMethodAnnotation(ReflectionClass::createFromName($tableClass), $method, Ignore::class)) {
                continue;
            }

            $class->addStmt(
                self::createMethod(
                    $method->name,
                    $method->params
                )
            );
        }

        $node = $this->factory->namespace($namespace)
            ->addStmt($this->factory->use(EntityInterface::class))
            ->addStmt($this->factory->use($tableClass)->as('BaseTable'))
            ->addStmt($this->factory->use(AsyncTable::class))
            ->addStmt($this->factory->use(AsyncTableInterface::class))
            ->addStmt($class)
            ->getNode()
        ;

        $prettyPrinter = new Standard();
        file_put_contents(
            $this->storageLocation . DIRECTORY_SEPARATOR . $hashedClass . '.php',
            $prettyPrinter->prettyPrintFile([
                $node
            ]) . PHP_EOL
        );

        return $generatedTable;
    }

    protected function createMethod($method, array $params)
    {
        return $this->factory->method($method)
            ->makePublic()
            ->addParams($params)
            ->addStmt(
                new Node\Stmt\Return_(
                    new Node\Expr\MethodCall(
                        new Node\Expr\Variable('this'),
                        'callAsyncOrSync',
                        [

array(new \PhpParser\Node\Scalar\String_($method), new \PhpParser\Node\Expr\Array_($this->createMethodArguments($params))) is of type array<integer,object<PhpParser\Node\Scalar\String_>|object<PhpParser\Node\Expr\Array_>,{"0":"object<PhpParser\\Node\\Scalar\\String_>","1":"object<PhpParser\\Node\\Expr\\Array_>"}>, but the function expects a array<integer,object<PhpParser\Node\Arg>>.

                            new Node\Scalar\String_($method),
                            new Node\Expr\Array_(
                                $this->createMethodArguments($params)
                            ),
                        ]
                    )
                )
            )
        ;
    }

    /**
     * @param array $params
     * @return array
     */
    protected function createMethodArguments(array $params)
    {
        $arguments = [];
        foreach ($params as $param) {
            if (!($param instanceof Node\Param)) {
                continue;
            }
            $arguments[] = new Node\Expr\Variable($param->name);
        }
        return $arguments;
    }

    /**
     * @param Node[] $ast
     * @return Generator
     */
    protected function extractMethods(array $ast)

This method seems to be duplicated in your project.

    {
        foreach ($ast as $node) {
            if (!isset($node->stmts)) {

Accessing stmts on the interface PhpParser\Node suggest that you code against a concrete implementation. How about adding an instanceof check?

                continue;
            }

            foreach ($this->iterageStmts($node->stmts) as $stmt) {

Accessing stmts on the interface PhpParser\Node suggest that you code against a concrete implementation. How about adding an instanceof check?

                yield $stmt;
            }
        }
    }

    protected function iterageStmts(array $stmts)

This method seems to be duplicated in your project.

    {
        foreach ($stmts as $stmt) {
            if ($stmt instanceof Node\Stmt\ClassMethod) {
                yield $stmt;
            }

            if (!isset($stmt->stmts)) {
                continue;
            }

            foreach ($this->iterageStmts($stmt->stmts) as $stmt) {
                yield $stmt;
            }
        }
    }

    protected function extractNamespace(array $ast)
    {
        foreach ($ast as $node) {
            if ($node instanceof Node\Stmt\Namespace_) {
                return (string)$node->name;
            }
        }

        return 'N' . uniqid('', true);
    }

    /**
     * @param ReflectionClass $reflectionClass
     * @param string $method
     * @param string $class
     * @return bool
     */
    private function hasMethodAnnotation(ReflectionClass $reflectionClass, $method, $class)
    {
        $methodReflection = $reflectionClass->getMethod($method);
        return is_a($this->annotationReader->getMethodAnnotation($methodReflection, $class), $class);

$methodReflection is of type object<BetterReflection\Reflection\ReflectionMethod>, but the function expects a object<ReflectionMethod>.

    }

}