File::matches() - Code Metrics - phpDocumentor/Reflection - Measure and Improve Code Quality continuously with Scrutinizer

File::matches() A
last analyzed 2020-01-03 19:55 UTC

↳ Parent: File

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
nc	1
nop	1
dl	0
loc	4
rs	10
c	0
b	0
f	0
ccs	2
cts	2
cp	1
crap	1

<?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\DocBlock as DocBlockInstance;
use phpDocumentor\Reflection\File as FileSystemFile;
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\NamespaceNodeToContext;
use PhpParser\Comment\Doc;
use PhpParser\Node;
use PhpParser\Node\Stmt\Class_ as ClassNode;
use PhpParser\Node\Stmt\Const_ as ConstantNode;
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;

    /**
     * @var callable
     */
    private $middlewareChain;

    /**
     * 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);
    }

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

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

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

        $this->createElements($nodes, $result, $command->getStrategies(), null);

        return $result;
    }

    /**
     * @param Node[] $nodes
     */
    private function createElements(
        array $nodes,
        FileElement $file,
        StrategyContainer $strategies,
        ?Context $context
    ) : void {
        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 ConstantNode::class:
                    $constants = new GlobalConstantIterator($node);

                    foreach ($constants as $constant) {
                        $strategy = $strategies->findMatching($constant);
                        $constant = $strategy->create($constant, $strategies, $context);
                        $file->addConstant($constant);

                    }
                    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:
                    $context = (new NamespaceNodeToContext())($node);
                    $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->stmts, $file, $strategies, $context);
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
     */
    protected function createFileDocBlock(
        ?Doc $docBlock = null,

        ?StrategyContainer $strategies = null,
        ?Context $context = null,
        array $nodes = []
    ) : ?DocBlockInstance {
        $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 ConstantNode ||
                $node instanceof ClassNode ||
                $node instanceof FunctionNode ||
                $node instanceof InterfaceNode ||
                $node instanceof TraitNode
            )) {
                return $this->createDocBlock($strategies, $comment, $context);
            }

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

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

        return null;
    }
}


File::matches() A
last analyzed 2020-01-03 19:55 UTC

Complexity

Size

Duplication

Code Coverage

Importance

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\DocBlock as DocBlockInstance;
18		use phpDocumentor\Reflection\File as FileSystemFile;
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\NamespaceNodeToContext;
28		use PhpParser\Comment\Doc;
29		use PhpParser\Node;
30		use PhpParser\Node\Stmt\Class_ as ClassNode;
31		use PhpParser\Node\Stmt\Const_ as ConstantNode;
32		use PhpParser\Node\Stmt\Function_ as FunctionNode;
33		use PhpParser\Node\Stmt\Interface_ as InterfaceNode;
34		use PhpParser\Node\Stmt\Namespace_ as NamespaceNode;
35		use PhpParser\Node\Stmt\Trait_ as TraitNode;
36
37		/**
38		* Strategy to create File element from the provided filename.
39		* This class supports extra middle wares to add extra steps to the creation process.
40		*/
41		final class File extends AbstractFactory implements ProjectFactoryStrategy
42		{
43		/**
44		* @var NodesFactory
45		*/
46		private $nodesFactory;
47
48		/**
49		* @var callable
50		*/
51		private $middlewareChain;
52
53		/**
54		* Initializes the object.
55		*
56		* @param Middleware[] $middleware
57		*/
58	13	public function __construct(NodesFactory $nodesFactory, $middleware = [])
59		{
60	13	$this->nodesFactory = $nodesFactory;
61
62	13	$lastCallable = function ($command) {
63	9	return $this->createFile($command);
64	13	};
65
66	13	$this->middlewareChain = ChainFactory::createExecutionChain($middleware, $lastCallable);
67	13	}
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	10	protected function doCreate($object, StrategyContainer $strategies, ?Context $context = null)
85		{
86	10	$command = new CreateCommand($object, $strategies);
87	10	$middlewareChain = $this->middlewareChain;
88
89	10	return $middlewareChain($command);
90		}
91
92		/**
93		* @return FileElement
94		*/
95	9	private function createFile(CreateCommand $command)
96		{
97	9	$file = $command->getFile();
98	9	$code = $file->getContents();
99	9	$nodes = $this->nodesFactory->create($code);
100
101	9	$docBlock = $this->createFileDocBlock(null, $command->getStrategies(), null, $nodes);
102
103	9	$result = new FileElement(
104	9	$file->md5(),
105	9	$file->path(),
106	9	$code,
107	9	$docBlock
108		);
109
110	9	$this->createElements($nodes, $result, $command->getStrategies(), null);
111
112	9	return $result;
113		}
114
115		/**
116		* @param Node[] $nodes
117		*/
118	9	private function createElements(
119		array $nodes,
120		FileElement $file,
121		StrategyContainer $strategies,
122		?Context $context
123		) : void {
124	9	foreach ($nodes as $node) {
125	9	switch (get_class($node)) {
126	9	case ClassNode::class:
127	2	$strategy = $strategies->findMatching($node);
128	2	$class = $strategy->create($node, $strategies, $context);
129	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...
130	2	break;
131	7	case ConstantNode::class:
132	1	$constants = new GlobalConstantIterator($node);
		0 ignored issues – show Compatibility introduced 2020-01-03 19:55 UTC by Report Bug Copy Issue Report `$node` of type `object<PhpParser\Node>` is not a sub-type of `object<PhpParser\Node\Stmt\Const_>`. It seems like you assume a concrete implementation of the interface `PhpParser\Node` 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...
133	1	foreach ($constants as $constant) {
134	1	$strategy = $strategies->findMatching($constant);
135	1	$constant = $strategy->create($constant, $strategies, $context);
136	1	$file->addConstant($constant);
		0 ignored issues – show Compatibility introduced 2020-01-03 19:55 UTC by Report Bug Copy Issue Report `$constant` of type `object<phpDocumentor\Reflection\Element>` is not a sub-type of `object<phpDocumentor\Reflection\Php\Constant>`. 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...
137		}
138	1	break;
139	6	case FunctionNode::class:
140	1	$strategy = $strategies->findMatching($node);
141	1	$function = $strategy->create($node, $strategies, $context);
142	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...
143	1	break;
144	5	case InterfaceNode::class:
145	1	$strategy = $strategies->findMatching($node);
146	1	$interface = $strategy->create($node, $strategies, $context);
147	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...
148	1	break;
149	4	case NamespaceNode::class:
150	3	$context = (new NamespaceNodeToContext())($node);
151	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...
152	3	$this->createElements($node->stmts, $file, $strategies, $context);
		0 ignored issues – show Bug introduced 2019-03-24 20:34 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...
153	3	break;
154	1	case TraitNode::class:
155	1	$strategy = $strategies->findMatching($node);
156	1	$trait = $strategy->create($node, $strategies, $context);
157	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...
158	9	break;
159		}
160		}
161	9	}
162
163		/**
164		* @param Node[] $nodes
165		*/
166	9	protected function createFileDocBlock(
167		?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...
168		?StrategyContainer $strategies = null,
169		?Context $context = null,
170		array $nodes = []
171		) : ?DocBlockInstance {
172	9	$node = current($nodes);
173	9	if (!$node instanceof Node) {
174		return null;
175		}
176
177	9	$comments = $node->getAttribute('comments');
178	9	if (!is_array($comments) \|\| empty($comments)) {
179	6	return null;
180		}
181
182	3	$found = 0;
183	3	$firstDocBlock = null;
184	3	foreach ($comments as $comment) {
185	3	if (!$comment instanceof Doc) {
186	1	continue;
187		}
188
189		// If current node cannot have a docblock return the first comment as docblock for the file.
190		if (!(
191	3	$node instanceof ConstantNode \|\|
192	3	$node instanceof ClassNode \|\|
193	2	$node instanceof FunctionNode \|\|
194	2	$node instanceof InterfaceNode \|\|
195	3	$node instanceof TraitNode
196		)) {
197	2	return $this->createDocBlock($strategies, $comment, $context);
198		}
199
200	1	++$found;
201	1	if ($firstDocBlock === null) {
202	1	$firstDocBlock = $comment;
203	1	} elseif ($found > 2) {
204	1	break;
205		}
206		}
207
208	1	if ($found === 2) {
209	1	return $this->createDocBlock($strategies, $firstDocBlock, $context);
210		}
211
212		return null;
213		}
214		}
215

phpDocumentor / Reflection

File::matches() A last analyzed 2020-01-03 19:55 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like

File::matches() A
last analyzed 2020-01-03 19:55 UTC