Cycle\ORM\Promise\ProxyCreator

Complexity

Total Complexity

8

Size/Duplication

Total Lines	113
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	20

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	21	1
A	make()	0	26	1
A	propertyName()	0	4	1
A	useStmts()	0	8	2
A	propertyType()	0	4	1
A	getNodesFromStub()	0	4	1
A	getStubFilename()	0	4	1

<?php
declare(strict_types=1);

namespace Cycle\ORM\Promise;

use Cycle\ORM\ORMInterface;
use Cycle\ORM\Promise\Declaration;
use PhpParser\Lexer;
use PhpParser\Parser;
use PhpParser\PrettyPrinter\Standard;
use PhpParser\PrettyPrinterAbstract;

class ProxyCreator
{
    private const PROPERTY = '__resolver';

    private const DEPENDENCIES = [
        'orm'    => ORMInterface::class,
        'target' => 'string',
        'scope'  => 'array'
    ];

    /** @var ConflictResolver */
    private $resolver;

    /** @var Traverser */
    private $traverser;

    /** @var Declaration\Extractor */
    private $extractor;

    /** @var Lexer */
    private $lexer;

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

    /** @var PrettyPrinterAbstract */
    private $printer;

    public function __construct(ConflictResolver $resolver, Traverser $traverser, Declaration\Extractor $extractor)
    {
        $this->resolver = $resolver;
        $this->traverser = $traverser;
        $this->extractor = $extractor;

        $lexer = new Lexer\Emulative([
            'usedAttributes' => [
                'comments',
                'startLine',
                'endLine',
                'startTokenPos',
                'endTokenPos',
            ],
        ]);

        $this->lexer = $lexer;
        $this->parser = new Parser\Php7($this->lexer);

        $this->printer = new Standard();
    }

    /**
     *
     * @param string $class
     * @param string $as
     *
     * @return string
     */
    public function make(string $class, string $as): string
    {
        $declaration = $this->extractor->extract($class);
        $schema = new Declaration\Schema($class, $as);

        $property = $this->propertyName($declaration);

        $visitors = [
            new Visitor\AddUseStmts($this->useStmts($schema)),
            new Visitor\UpdateNamespace($schema->class->namespace),
            new Visitor\DeclareClass($schema->class->class, $schema->extends->class),
            new Visitor\AddResolverProperty($property, $this->propertyType(), $schema->extends->class),
            new Visitor\UpdateConstructor($declaration->hasConstructor, $property, $this->propertyType(), self::DEPENDENCIES),
            new Visitor\UpdatePromiseMethods($property),
            new Visitor\AddProxiedMethods($property, $declaration->methods),
        ];

        $nodes = $this->getNodesFromStub();
        $output = $this->traverser->traverseClonedNodes($nodes, ...$visitors);

        return $this->printer->printFormatPreserving(
            $output,
            $nodes,

It seems like $nodes defined by $this->getNodesFromStub() on line 87 can also be of type null; however, PhpParser\PrettyPrinterAbstract::printFormatPreserving() does only seem to accept array<integer,object<PhpParser\Node>>, maybe add an additional type check?

            $this->lexer->getTokens()
        );
    }

    private function propertyName(Declaration\Declaration $declaration): string
    {
        return $this->resolver->resolve($declaration->properties, self::PROPERTY);
    }

    private function useStmts(Declaration\Schema $schema): array
    {
        if ($schema->class->namespace !== $schema->extends->namespace) {
            return [$schema->extends->getNamespacesName()];
        }

        return [];
    }

    private function propertyType(): string
    {
        return Utils::shortName(PromiseResolver::class);
    }

    private function getNodesFromStub()
    {
        return $this->parser->parse(file_get_contents($this->getStubFilename()));
    }

    private function getStubFilename(): string
    {
        return dirname(__DIR__) . DIRECTORY_SEPARATOR . 'stubs' . DIRECTORY_SEPARATOR . 'proxy.stub';
    }
}