PHPSA\Definition\FileParser

Complexity

Total Complexity

31

Size/Duplication

Total Lines	159
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	21

Test Coverage

Coverage

68.75%

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
C	parserFile()	0	51	9
C	parseTopDefinitions()	0	66	21

<?php
/**
 * @author Patsura Dmitry https://github.com/ovr <talk@dmtry.me>
 */

namespace PHPSA\Definition;

use Exception;
use PHPSA\AliasManager;
use PHPSA\Compiler;
use PHPSA\Context;
use PhpParser\Node;
use RuntimeException;

class FileParser
{
    /**
     * @var \PhpParser\Parser
     */
    protected $parser;

    /**
     * @var \PhpParser\NodeTraverser
     */
    protected $nodeTraverser;

    /**
     * @var Compiler
     */
    protected $compiler;

    /**
     * @param \PhpParser\Parser $parser
     * @param Compiler $compiler
     */
    public function __construct(\PhpParser\Parser $parser, Compiler $compiler)
    {
        $this->nodeTraverser = new \PhpParser\NodeTraverser();
        $this->nodeTraverser->addVisitor(new \PhpParser\NodeVisitor\NameResolver);

        $this->parser = $parser;
        $this->compiler = $compiler;
    }

    /**
     * @param string $filepath
     * @param Context $context
     * @throws RuntimeException when filepath is not readable
     */
    public function parserFile($filepath, Context $context)
    {
        $context->setFilepath($filepath);

        try {
            if (!is_readable($filepath)) {
                throw new RuntimeException('File ' . $filepath . ' is not readable');
            }

            $context->debug('<comment>Precompile: ' . $filepath . '.</comment>');

            $code = file_get_contents($filepath);
            $astTree = $this->parser->parse($code);

            $this->nodeTraverser->traverse($astTree);

It seems like $astTree defined by $this->parser->parse($code) on line 62 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?

            $context->aliasManager = new AliasManager();
            $namespace = null;

            /**
             * Step 1 Precompile
             */
            foreach ($astTree as $topStatement) {

The expression $astTree of type array<integer,object<PhpParser\Node>>|null is not guaranteed to be traversable. How about adding an additional type check?

                if ($topStatement instanceof Node\Stmt\Namespace_) {
                    /**
                     * Namespace block can be created without NS name
                     */
                    if ($topStatement->name) {
                        $namespace = $topStatement->name->toString();
                        $context->aliasManager->setNamespace($namespace);
                    }

                    if ($topStatement->stmts) {

The expression $topStatement->stmts of type PhpParser\Node[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

                        $this->parseTopDefinitions($topStatement->stmts, $context->aliasManager, $filepath);

$topStatement->stmts is of type array<integer,object<PhpParser\Node>>, but the function expects a object<PhpParser\Node\Stmt>|array<integer,object<PhpParser\Node\Stmt>>.

                    }
                } else {
                    if (is_array($topStatement)) {
                        $this->parseTopDefinitions($topStatement, $context->aliasManager, $filepath);
                    } else {
                        $this->parseTopDefinitions($astTree, $context->aliasManager, $filepath);

$astTree is of type array<integer,object<PhpParser\Node>>|null, but the function expects a object<PhpParser\Node\Stmt>|array<integer,object<PhpParser\Node\Stmt>>.

                    }
                }
            }

            $context->clear();
        } catch (\PhpParser\Error $e) {
            $context->syntaxError($e, $filepath);
        } catch (Exception $e) {
            $context->output->writeln("<error>{$e->getMessage()}</error>");
        }
    }

    /**
     * @param Node\Stmt|Node\Stmt[] $topStatement
     * @param AliasManager $aliasManager
     * @param string $filepath
     */
    protected function parseTopDefinitions($topStatement, AliasManager $aliasManager, $filepath)
    {
        foreach ($topStatement as $statement) {

The expression $topStatement of type object<PhpParser\Node\Stmt>|array<integer,object<PhpParser\Node\Stmt>> is not guaranteed to be traversable. How about adding an additional type check?

            if ($statement instanceof Node\Stmt\Use_) {
                if (count($statement->uses) > 0) {
                    foreach ($statement->uses as $use) {
                        $aliasManager->add($use->name->parts);
                    }
                }
            } elseif ($statement instanceof Node\Stmt\GroupUse) {
                if (count($statement->uses) > 0) {
                    foreach ($statement->uses as $use) {
                        $aliasManager->add($statement->prefix . $use->name->parts);
                    }
                }
            } elseif ($statement instanceof Node\Stmt\Trait_) {
                $definition = new TraitDefinition($statement->name, $statement);
                $definition->setFilepath($filepath);
                $definition->setNamespace($aliasManager->getNamespace());
                $definition->precompile();

                $this->compiler->addTrait($definition);
            } elseif ($statement instanceof Node\Stmt\Class_) {
                $definition = new ClassDefinition($statement->name, $statement, $statement->type);
                $definition->setFilepath($filepath);
                $definition->setNamespace($aliasManager->getNamespace());

                if ($statement->extends) {
                    $definition->setExtendsClass($statement->extends->toString());
                }

                if ($statement->implements) {

The expression $statement->implements of type PhpParser\Node\Name[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

                    foreach ($statement->implements as $interface) {
                        $definition->addInterface($interface->toString());
                    }
                }

                foreach ($statement->stmts as $stmt) {
                    if ($stmt instanceof Node\Stmt\ClassMethod) {
                        $definition->addMethod(
                            new ClassMethod($stmt->name, $stmt, $stmt->type)
                        );
                    } elseif ($stmt instanceof Node\Stmt\Property) {
                        $definition->addProperty($stmt);
                    } elseif ($stmt instanceof Node\Stmt\TraitUse) {
                        foreach ($stmt->traits as $traitPart) {
                            $traitDefinition = $this->compiler->getTrait($traitPart->toString());

Are you sure the assignment to $traitDefinition is correct as $this->compiler->getTrait($traitPart->toString()) (which targets PHPSA\Compiler::getTrait()) seems to always return null.

                            if ($traitDefinition) {
                                $definition->mergeTrait($traitDefinition, $stmt->adaptations);

$stmt->adaptations is of type array<integer,object<PhpParser\Node\Stmt\TraitUseAdaptation>>, but the function expects a array<integer,object<PhpParser\Node\Stmt\TraitUseAdaptation\Alias>>.

                            }
                        }
                    } elseif ($stmt instanceof Node\Stmt\ClassConst) {
                        $definition->addConst($stmt);
                    }
                }

                $this->compiler->addClass($definition);
            } elseif ($statement instanceof Node\Stmt\Function_) {
                $definition = new FunctionDefinition($statement->name, $statement);
                $definition->setFilepath($filepath);
                $definition->setNamespace($aliasManager->getNamespace());

                $this->compiler->addFunction($definition);
            }
        }
    }
}