File::createFileDocBlock() - Code Metrics - Inspection of "Strict Typing" - phpDocumentor/Reflection - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — develop (#126)

by Chuck

created 2018-02-14 19:13 UTC

File::createFileDocBlock() C

↳ Parent: File

Complexity

Conditions	13
Paths	13

Size

Total Lines	47
Code Lines	30

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	23
CRAP Score	13.0864

Importance

Changes

Metric	Value
cc	13
eloc	30
nc	13
nop	4
dl	0
loc	47
ccs	23
cts	25
cp	0.92
crap	13.0864
rs	5.0999
c	0
b	0
f	0

How to fix Complexity

<?php
declare(strict_types=1);

/**
 * 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-2018 Mike van Riel<[email protected]>
 * @license   http://www.opensource.org/licenses/mit-license.php MIT
 * @link      http://phpdoc.org
 */

namespace phpDocumentor\Reflection\Php\Factory;

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\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;

/**
 * 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
{
    /**
     * @var NodesFactory
     */
    private $nodesFactory;

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

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

        $this->middlewareChain = ChainFactory::createExecutionChain($middleware, $lastCallable);
class MyClass { }

$x = new MyClass();
$x->foo = true;
    }

    /**
     * Returns true when the strategy is able to handle the object.
     *
     *
     * @param mixed $file path to check.
     */
    public function matches($file): bool
    {
        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.
     * @return File
     */
    protected function doCreate($object, StrategyContainer $strategies, Context $context = null)
    {
        $command = new CreateCommand($object, $strategies);
        $middlewareChain = $this->middlewareChain;

        return $middlewareChain($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
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        );

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

        return $result;
    }

    /**
     * @param Node[] $nodes
     */
    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);

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

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

                    break;
                case NamespaceNode::class:
                    $file->addNamespace($node->fqsen);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                    $this->createElements($node->fqsen, $node->stmts, $file, $strategies);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                    break;
                case TraitNode::class:
                    $strategy = $strategies->findMatching($node);
                    $trait = $strategy->create($node, $strategies, $context);
                    $file->addTrait($trait);

                    break;
            }
        }
    }

    /**
     * @param Node[] $nodes
     * @return null|\phpDocumentor\Reflection\DocBlock
     */
    protected function createFileDocBlock(
        Doc $docBlock = null,

        StrategyContainer $strategies = null,
        Context $context = null,
        $nodes = []
    ) {
        $node = current($nodes);
        if (!$node instanceof Node) {
            return null;
        }

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

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

            //If current node cannot have a docblock return the first comment as docblock for the file.
            if (!(
                $node instanceof ClassNode ||
                $node instanceof FunctionNode ||
                $node instanceof InterfaceNode ||
                $node instanceof TraitNode
            )) {
                return $this->createDocBlock($strategies, $comment, $context);
function notNullable(stdClass $x) { }

// Unsafe
function withoutCheck(stdClass $x = null) {
    notNullable($x);
}

// Safe - Alternative 1: Adding Additional Type-Check
function withCheck(stdClass $x = null) {
    if ($x instanceof stdClass) {
        notNullable($x);
    }
}

// Safe - Alternative 2: Changing Parameter
function withNonNullableParam(stdClass $x) {
    notNullable($x);
}
            }

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

        if ($found === 2) {
            return $this->createDocBlock($strategies, $firstDocBlock, $context);
function notNullable(stdClass $x) { }

// Unsafe
function withoutCheck(stdClass $x = null) {
    notNullable($x);
}

// Safe - Alternative 1: Adding Additional Type-Check
function withCheck(stdClass $x = null) {
    if ($x instanceof stdClass) {
        notNullable($x);
    }
}

// Safe - Alternative 2: Changing Parameter
function withNonNullableParam(stdClass $x) {
    notNullable($x);
}
        }

        return null;
    }
}


Pull Request — develop (#126)

File::createFileDocBlock() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Complexity

Long Method

Available Fixes

Available Fixes

Available Fixes

1		<?php
2		declare(strict_types=1);
3
4		/**
5		* This file is part of phpDocumentor.
6		*
7		* For the full copyright and license information, please view the LICENSE
8		* file that was distributed with this source code.
9		*
10		* @copyright 2010-2018 Mike van Riel<[email protected]>
11		* @license http://www.opensource.org/licenses/mit-license.php MIT
12		* @link http://phpdoc.org
13		*/
14
15		namespace phpDocumentor\Reflection\Php\Factory;
16
17		use phpDocumentor\Reflection\File as FileSystemFile;
18		use phpDocumentor\Reflection\Fqsen;
19		use phpDocumentor\Reflection\Middleware\ChainFactory;
20		use phpDocumentor\Reflection\Middleware\Middleware;
21		use phpDocumentor\Reflection\Php\Factory\File\CreateCommand;
22		use phpDocumentor\Reflection\Php\File as FileElement;
23		use phpDocumentor\Reflection\Php\NodesFactory;
24		use phpDocumentor\Reflection\Php\ProjectFactoryStrategy;
25		use phpDocumentor\Reflection\Php\StrategyContainer;
26		use phpDocumentor\Reflection\Types\Context;
27		use phpDocumentor\Reflection\Types\ContextFactory;
28		use PhpParser\Comment\Doc;
29		use PhpParser\Node;
30		use PhpParser\Node\Stmt\Class_ as ClassNode;
31		use PhpParser\Node\Stmt\Function_ as FunctionNode;
32		use PhpParser\Node\Stmt\Interface_ as InterfaceNode;
33		use PhpParser\Node\Stmt\Namespace_ as NamespaceNode;
34		use PhpParser\Node\Stmt\Trait_ as TraitNode;
35
36		/**
37		* Strategy to create File element from the provided filename.
38		* This class supports extra middle wares to add extra steps to the creation process.
39		*/
40		final class File extends AbstractFactory implements ProjectFactoryStrategy
41		{
42		/**
43		* @var NodesFactory
44		*/
45		private $nodesFactory;
46
47		/**
48		* Initializes the object.
49		*
50		* @param Middleware[] $middleware
51		*/
52	12	public function __construct(NodesFactory $nodesFactory, $middleware = [])
53		{
54	12	$this->nodesFactory = $nodesFactory;
55
56	12	$lastCallable = function ($command) {
57	8	return $this->createFile($command);
58	12	};
59
60	12	$this->middlewareChain = ChainFactory::createExecutionChain($middleware, $lastCallable);
		0 ignored issues – show Bug introduced 2015-11-23 21:15 UTC by Report Bug Copy Issue Report The property `middlewareChain` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
61	12	}
62
63		/**
64		* Returns true when the strategy is able to handle the object.
65		*
66		*
67		* @param mixed $file path to check.
68		*/
69	1	public function matches($file): bool
70		{
71	1	return $file instanceof FileSystemFile;
72		}
73
74		/**
75		* Creates an File out of the given object.
76		*
77		* Since an object might contain other objects that need to be converted the $factory is passed so it can be
78		* used to create nested Elements.
79		*
80		* @param FileSystemFile $object path to the file to convert to an File object.
81		* @param StrategyContainer $strategies used to convert nested objects.
82		* @return File
83		*/
84	9	protected function doCreate($object, StrategyContainer $strategies, Context $context = null)
85		{
86	9	$command = new CreateCommand($object, $strategies);
87	9	$middlewareChain = $this->middlewareChain;
88
89	9	return $middlewareChain($command);
90		}
91
92		/**
93		* @return FileElement
94		*/
95	8	private function createFile(CreateCommand $command)
96		{
97	8	$file = $command->getFile();
98	8	$code = $file->getContents();
99	8	$nodes = $this->nodesFactory->create($code);
100
101	8	$contextFactory = new ContextFactory();
102	8	$context = $contextFactory->createForNamespace('\\', $code);
103
104	8	$docBlock = $this->createFileDocBlock(null, $command->getStrategies(), $context, $nodes);
105
106	8	$result = new FileElement(
107	8	$file->md5(),
108	8	$file->path(),
109	8	$code,
110	8	$docBlock
		0 ignored issues – show Bug introduced 2017-08-30 19:12 UTC by Report Bug Copy Issue Report It seems like `$docBlock` defined by `$this->createFileDocBloc...es(), $context, $nodes)` on line `104` 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? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
111		);
112
113	8	$this->createElements(new Fqsen('\\'), $nodes, $result, $command->getStrategies());
114
115	8	return $result;
116		}
117
118		/**
119		* @param Node[] $nodes
120		*/
121	8	private function createElements(Fqsen $namespace, $nodes, FileElement $file, StrategyContainer $strategies)
122		{
123	8	$contextFactory = new ContextFactory();
124	8	$context = $contextFactory->createForNamespace((string) $namespace, $file->getSource());
125	8	foreach ($nodes as $node) {
126	8	switch (get_class($node)) {
127	8	case ClassNode::class:
128	2	$strategy = $strategies->findMatching($node);
129	2	$class = $strategy->create($node, $strategies, $context);
130	2	$file->addClass($class);
		0 ignored issues – show Compatibility introduced 2015-11-23 21:15 UTC by Report Bug Copy Issue Report `$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. This check looks for parameters that are defined as one type in their type hint or doc comment but seem to be used as a narrower type, i.e an implementation of an interface or a subclass. Consider changing the type of the parameter or doing an instanceof check before assuming your parameter is of the expected type. Loading history...
131	2	break;
132	6	case FunctionNode::class:
133	1	$strategy = $strategies->findMatching($node);
134	1	$function = $strategy->create($node, $strategies, $context);
135	1	$file->addFunction($function);
		0 ignored issues – show Compatibility introduced 2015-11-23 21:15 UTC by Report Bug Copy Issue Report `$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. This check looks for parameters that are defined as one type in their type hint or doc comment but seem to be used as a narrower type, i.e an implementation of an interface or a subclass. Consider changing the type of the parameter or doing an instanceof check before assuming your parameter is of the expected type. Loading history...
136	1	break;
137	5	case InterfaceNode::class:
138	1	$strategy = $strategies->findMatching($node);
139	1	$interface = $strategy->create($node, $strategies, $context);
140	1	$file->addInterface($interface);
		0 ignored issues – show Compatibility introduced 2015-11-23 21:15 UTC by Report Bug Copy Issue Report `$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. This check looks for parameters that are defined as one type in their type hint or doc comment but seem to be used as a narrower type, i.e an implementation of an interface or a subclass. Consider changing the type of the parameter or doing an instanceof check before assuming your parameter is of the expected type. Loading history...
141	1	break;
142	4	case NamespaceNode::class:
143	3	$file->addNamespace($node->fqsen);
		0 ignored issues – show Bug introduced 2015-11-23 21:15 UTC by Report Bug Copy Issue Report Accessing `fqsen` on the interface `PhpParser\Node` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
144	3	$this->createElements($node->fqsen, $node->stmts, $file, $strategies);
		0 ignored issues – show Bug introduced 2015-11-23 21:15 UTC by Report Bug Copy Issue Report Accessing `fqsen` on the interface `PhpParser\Node` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history... Bug introduced 2015-11-23 21:15 UTC by Report Bug Copy Issue Report Accessing `stmts` on the interface `PhpParser\Node` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
145	3	break;
146	1	case TraitNode::class:
147	1	$strategy = $strategies->findMatching($node);
148	1	$trait = $strategy->create($node, $strategies, $context);
149	1	$file->addTrait($trait);
		0 ignored issues – show Compatibility introduced 2015-11-23 21:15 UTC by Report Bug Copy Issue Report `$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. This check looks for parameters that are defined as one type in their type hint or doc comment but seem to be used as a narrower type, i.e an implementation of an interface or a subclass. Consider changing the type of the parameter or doing an instanceof check before assuming your parameter is of the expected type. Loading history...
150	8	break;
151		}
152		}
153	8	}
154
155		/**
156		* @param Node[] $nodes
157		* @return null\|\phpDocumentor\Reflection\DocBlock
158		*/
159	8	protected function createFileDocBlock(
160		Doc $docBlock = null,
		0 ignored issues – show Unused Code introduced 2017-12-24 21:12 UTC by Report Bug Copy Issue Report The parameter `$docBlock` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
161		StrategyContainer $strategies = null,
162		Context $context = null,
163		$nodes = []
164		) {
165	8	$node = current($nodes);
166	8	if (!$node instanceof Node) {
167		return null;
168		}
169
170	8	$comments = $node->getAttribute('comments');
171	8	if (!is_array($comments) \|\| empty($comments)) {
172	5	return null;
173		}
174
175	3	$found = 0;
176	3	$firstDocBlock = null;
177	3	foreach ($comments as $comment) {
178	3	if (!$comment instanceof Doc) {
179	1	continue;
180		}
181
182		//If current node cannot have a docblock return the first comment as docblock for the file.
183		if (!(
184	3	$node instanceof ClassNode \|\|
185	2	$node instanceof FunctionNode \|\|
186	2	$node instanceof InterfaceNode \|\|
187	3	$node instanceof TraitNode
188		)) {
189	2	return $this->createDocBlock($strategies, $comment, $context);
		0 ignored issues – show Bug introduced 2016-12-27 20:24 UTC by Report Bug Copy Issue Report It seems like `$strategies` defined by parameter `$strategies` on line `161` can be `null`; however, `phpDocumentor\Reflection...ctory::createDocBlock()` does not accept `null`, maybe add an additional type check? It seems like you allow that null is being passed for a parameter, however the function which is called does not seem to accept null. We recommend to add an additional type check (or disallow null for the parameter): function notNullable(stdClass $x) { } // Unsafe function withoutCheck(stdClass $x = null) { notNullable($x); } // Safe - Alternative 1: Adding Additional Type-Check function withCheck(stdClass $x = null) { if ($x instanceof stdClass) { notNullable($x); } } // Safe - Alternative 2: Changing Parameter function withNonNullableParam(stdClass $x) { notNullable($x); } Loading history...
190		}
191
192	1	++$found;
193	1	if ($firstDocBlock === null) {
194	1	$firstDocBlock = $comment;
195	1	} elseif ($found > 2) {
196	1	break;
197		}
198		}
199
200	1	if ($found === 2) {
201	1	return $this->createDocBlock($strategies, $firstDocBlock, $context);
		0 ignored issues – show Bug introduced 2016-12-27 20:24 UTC by Report Bug Copy Issue Report It seems like `$strategies` defined by parameter `$strategies` on line `161` can be `null`; however, `phpDocumentor\Reflection...ctory::createDocBlock()` does not accept `null`, maybe add an additional type check? It seems like you allow that null is being passed for a parameter, however the function which is called does not seem to accept null. We recommend to add an additional type check (or disallow null for the parameter): function notNullable(stdClass $x) { } // Unsafe function withoutCheck(stdClass $x = null) { notNullable($x); } // Safe - Alternative 1: Adding Additional Type-Check function withCheck(stdClass $x = null) { if ($x instanceof stdClass) { notNullable($x); } } // Safe - Alternative 2: Changing Parameter function withNonNullableParam(stdClass $x) { notNullable($x); } Loading history...
202		}
203
204		return null;
205		}
206		}
207

phpDocumentor / Reflection

Pull Request — develop (#126)

File::createFileDocBlock() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Complexity

Long Method

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like