exussum12\CoverageChecker\FileParser

Complexity

Total Complexity

19

Size/Duplication

Total Lines	98
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	getClassLimits()	0	4	1
A	getFunctionLimits()	0	4	1
A	parse()	0	7	2
A	getCodeLimits()	0	10	2
A	addClass()	0	4	1
A	addFunction()	0	4	1
A	handleClass()	0	8	2
A	handleFunction()	0	4	1
A	handleNamespace()	0	6	2
B	handleNode()	0	15	5

<?php
namespace exussum12\CoverageChecker;

use PhpParser\Node;
use PhpParser\Parser;
use PhpParser\ParserFactory;

class FileParser
{
    protected $sourceCode = '';
    protected $classes = [];
    protected $functions = [];

    public function __construct($sourceCode)
    {
        $this->sourceCode = $sourceCode;
        $parser = (new ParserFactory)->create(ParserFactory::PREFER_PHP7);
        $this->parse($parser);
    }

    /**
     * @return CodeLimits[]
     */
    public function getClassLimits()
    {
        return $this->classes;
    }

    /**
     * @return CodeLimits[]
     */
    public function getFunctionLimits()
    {
        return $this->functions;
    }

    protected function parse(Parser $parser)
    {
        $ast = $parser->parse($this->sourceCode);
        foreach ($ast as $node) {

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

            $this->handleNode($node);
        }
    }

    protected function getCodeLimits(Node $node)
    {
        $startLine = $node->getAttribute('startLine');
        $endLine = $node->getAttribute('endLine');
        if ($node->getDocComment()) {
            $startLine = $node->getDocComment()->getLine();
        }

        return new CodeLimits($startLine, $endLine);
    }

    protected function addClass($classLimits)
    {
        $this->classes[] = $classLimits;
    }

    protected function addFunction($classLimits)
    {
        $this->functions[] = $classLimits;
    }

    protected function handleClass(Node $node)
    {
        $this->addClass($this->getCodeLimits($node));

        foreach ($node->getMethods() as $function) {

It seems like you code against a concrete implementation and not the interface PhpParser\Node as the method getMethods() does only exist in the following implementations of said interface: PhpParser\Node\Stmt\ClassLike, PhpParser\Node\Stmt\Class_, PhpParser\Node\Stmt\Interface_, PhpParser\Node\Stmt\Trait_.

            $this->handleNode($function);
        }
    }

    protected function handleFunction(Node $node)
    {
        $this->addFunction($this->getCodeLimits($node));
    }

    private function handleNamespace(Node $node)
    {
        foreach ($node->stmts as $part) {

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

            $this->handleNode($part);
        }
    }

    /**
     * @param $node
     */
    protected function handleNode($node)
    {
        $type = $node->getType();
        if ($type == 'Stmt_Namespace') {
            $this->handleNamespace($node);
        }

        if ($type == 'Stmt_Class') {
            $this->handleClass($node);
        }

        if ($type == "Stmt_Function" || $type == "Stmt_ClassMethod") {
            $this->handleFunction($node);
        }
    }
}