phpDocumentor\Reflection\Php\Factory\File

Complexity

Total Complexity

21

Size/Duplication

Total Lines	169
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	11

Test Coverage

Coverage

97.3%

Importance

Changes	5
Bugs	0	Features	2

6 Methods

Rating	Name	Duplication	Size	Complexity
A	doCreate()	0	7	1
A	__construct()	0	10	1
A	matches()	0	4	1
A	createFile()	0	22	1
D	createFileDocBlock()	0	41	10
C	createElements()	0	33	7

<?php
/**
 * This file is part of phpDocumentor.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * @copyright 2010-2015 Mike van Riel<mike@phpdoc.org>
 * @license   http://www.opensource.org/licenses/mit-license.php MIT
 * @link      http://phpdoc.org
 */


namespace phpDocumentor\Reflection\Php\Factory;

use InvalidArgumentException;
use phpDocumentor\Reflection\File as FileSystemFile;
use phpDocumentor\Reflection\Fqsen;
use phpDocumentor\Reflection\Middleware\ChainFactory;
use phpDocumentor\Reflection\Middleware\Middleware;
use phpDocumentor\Reflection\Php\Factory\File\CreateCommand;
use phpDocumentor\Reflection\Php\File as FileElement;
use phpDocumentor\Reflection\Php\NodesFactory;
use phpDocumentor\Reflection\Php\ProjectFactoryStrategy;
use phpDocumentor\Reflection\Php\StrategyContainer;
use phpDocumentor\Reflection\Types\Context;
use phpDocumentor\Reflection\Types\ContextFactory;
use PhpParser\Comment\Doc;
use PhpParser\Lexer;
use PhpParser\Node;
use PhpParser\Node\Stmt\Class_ as ClassNode;
use PhpParser\Node\Stmt\Function_ as FunctionNode;
use PhpParser\Node\Stmt\Interface_ as InterfaceNode;
use PhpParser\Node\Stmt\Namespace_ as NamespaceNode;
use PhpParser\Node\Stmt\Trait_ as TraitNode;
use PhpParser\NodeAbstract;

/**
 * Strategy to create File element from the provided filename.
 * This class supports extra middle wares to add extra steps to the creation process.
 */
final class File extends AbstractFactory implements ProjectFactoryStrategy

The class File has a coupling between objects value of 20. Consider to reduce the number of dependencies under 13.

{
    /**
     * @var NodesFactory
     */
    private $nodesFactory;

    /**
     * Initializes the object.
     *
     * @param NodesFactory $nodesFactory
     * @param Middleware[] $middleware
     */
    public function __construct(NodesFactory $nodesFactory, $middleware = array())
    {
        $this->nodesFactory = $nodesFactory;

        $lastCallable = function ($command) {
            return $this->createFile($command);
        };

        $this->middlewareChain = ChainFactory::createExecutionChain($middleware, $lastCallable);

The property middlewareChain does not exist. Did you maybe forget to declare it?

    }

    /**
     * Returns true when the strategy is able to handle the object.
     *
     * @param string $file path to check.
     * @return boolean
     */
    public function matches($file)
    {
        return $file instanceof FileSystemFile;
    }

    /**
     * Creates an File out of the given object.
     * Since an object might contain other objects that need to be converted the $factory is passed so it can be
     * used to create nested Elements.
     *
     * @param FileSystemFile $object path to the file to convert to an File object.
     * @param StrategyContainer $strategies used to convert nested objects.
     * @param Context $context
     * @return File
     */
    protected function doCreate($object, StrategyContainer $strategies, Context $context = null)
    {
        $command = new CreateCommand($object, $strategies);
        $middlewareChain = $this->middlewareChain;

        return $middlewareChain($command);
    }

    /**
     * @param CreateCommand $command
     * @return FileElement
     */
    private function createFile(CreateCommand $command)
    {
        $file = $command->getFile();
        $code = $file->getContents();
        $nodes = $this->nodesFactory->create($code);

        $contextFactory = new ContextFactory();
        $context = $contextFactory->createForNamespace('\\', $code);

        $docBlock = $this->createFileDocBlock(null, $command->getStrategies(), $context, $nodes);

        $result = new FileElement(
            $file->md5(),
            $file->path(),
            $code,
            $docBlock

It seems like $docBlock defined by $this->createFileDocBlock(null, $command->getStrategies(), $context, $nodes) on line 108 can also be of type object<phpDocumentor\Reflection\Element>; however, phpDocumentor\Reflection\Php\File::__construct() does only seem to accept null|object<phpDocumentor\Reflection\DocBlock>, maybe add an additional type check?

        );

        $this->createElements(new Fqsen('\\'), $nodes, $result, $command->getStrategies());

        return $result;
    }

    /**
     * @param Fqsen $namespace
     * @param Node[] $nodes
     * @param FileElement $file
     * @param StrategyContainer $strategies
     */
    private function createElements(Fqsen $namespace, $nodes, FileElement $file, StrategyContainer $strategies)
    {
        $contextFactory = new ContextFactory();
        $context = $contextFactory->createForNamespace((string)$namespace, $file->getSource());
        foreach ($nodes as $node) {
            switch (get_class($node)) {
                case ClassNode::class:
                    $strategy = $strategies->findMatching($node);
                    $class = $strategy->create($node, $strategies, $context);
                    $file->addClass($class);

$class of type object<phpDocumentor\Reflection\Element> is not a sub-type of object<phpDocumentor\Reflection\Php\Class_>. It seems like you assume a concrete implementation of the interface phpDocumentor\Reflection\Element to be always present.

                    break;
                case FunctionNode::class:
                    $strategy = $strategies->findMatching($node);
                    $function = $strategy->create($node, $strategies, $context);
                    $file->addFunction($function);

$function of type object<phpDocumentor\Reflection\Element> is not a sub-type of object<phpDocumentor\Reflection\Php\Function_>. It seems like you assume a concrete implementation of the interface phpDocumentor\Reflection\Element to be always present.

                    break;
                case InterfaceNode::class:
                    $strategy = $strategies->findMatching($node);
                    $interface = $strategy->create($node, $strategies, $context);
                    $file->addInterface($interface);

$interface of type object<phpDocumentor\Reflection\Element> is not a sub-type of object<phpDocumentor\Reflection\Php\Interface_>. It seems like you assume a concrete implementation of the interface phpDocumentor\Reflection\Element to be always present.

                    break;
                case NamespaceNode::class:
                    $file->addNamespace($node->fqsen);

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

                    $this->createElements($node->fqsen, $node->stmts, $file, $strategies);

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

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

                    break;
                case TraitNode::class:
                    $strategy = $strategies->findMatching($node);
                    $trait = $strategy->create($node, $strategies, $context);
                    $file->addTrait($trait);

$trait of type object<phpDocumentor\Reflection\Element> is not a sub-type of object<phpDocumentor\Reflection\Php\Trait_>. It seems like you assume a concrete implementation of the interface phpDocumentor\Reflection\Element to be always present.

                    break;
            }
        }
    }

    /**
     * @param Doc $docBlock
     * @param StrategyContainer $strategies
     * @param Context $context
     * @param Node[] $nodes
     * @return null|\phpDocumentor\Reflection\Element
     */
    protected function createFileDocBlock(
        Doc $docBlock = null,
        StrategyContainer $strategies = null,
        Context $context = null,
        $nodes = array()
    ) {
        $node = current($nodes);
        if (!$node instanceof Node) {
            return $docBlock;
        }

        $comments = $node->getAttribute('comments');
        if (!is_array($comments) || empty($comments)) {
            return $docBlock;
        }

        $found = 0;
        $firstDocBlock = null;
        foreach ($comments as $comment) {
            if (!$comment instanceof Doc) {
                continue;
            }

            if ($node instanceof NamespaceNode) {
                return $this->createDocBlock($strategies, $comment, $context);

It seems like $strategies defined by parameter $strategies on line 171 can be null; however, phpDocumentor\Reflection\Php\Factory\AbstractFactory::createDocBlock() does not accept null, maybe add an additional type check?

            }

            $found++;
            if ($firstDocBlock === null) {
                $firstDocBlock = $comment;
            } elseif ($found > 2) {
                break;
            }
        }

        if ($found === 2) {
            return $this->createDocBlock($strategies, $firstDocBlock, $context);

It seems like $strategies defined by parameter $strategies on line 171 can be null; however, phpDocumentor\Reflection\Php\Factory\AbstractFactory::createDocBlock() does not accept null, maybe add an additional type check?

        }

        return $docBlock;
    }
}