FileMetadataIntrospectionVisitor::afterTraverse() - Code Metrics - RunOpenCode/abstract-builder - Measure and Improve Code Quality continuously with Scrutinizer

FileMetadataIntrospectionVisitor::afterTraverse() A
last analyzed 2017-07-09 08:12 UTC

↳ Parent: FileMetadataIntrospectionVisitor

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

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

<?php

namespace RunOpenCode\AbstractBuilder\Ast\Visitor;

use PhpParser\Node;
use PhpParser\NodeVisitorAbstract;
use PhpParser\Node\Stmt;
use RunOpenCode\AbstractBuilder\Ast\Metadata\ClassMetadata;
use RunOpenCode\AbstractBuilder\Ast\Metadata\FileMetadata;
use RunOpenCode\AbstractBuilder\Ast\Metadata\MethodMetadata;
use RunOpenCode\AbstractBuilder\Ast\Metadata\TraitMetadata;
use RunOpenCode\AbstractBuilder\Ast\MetadataLoader;
use RunOpenCode\AbstractBuilder\Utils\MethodUtils;

/**
 * Class FileMetadataIntrospectionVisitor
 *
 * @package RunOpenCode\AbstractBuilder\Ast\Visitor
 */
class FileMetadataIntrospectionVisitor extends NodeVisitorAbstract
{
    /**
     * @var string
     */
    private $filename;

    /**
     * @var array
     */
    private $uses;

    /**
     * @var ClassMetadata[]
     */
    private $classes;

    /**
     * @var TraitMetadata[]
     */
    private $traits;

    /**
     * @var array
     */
    private $ast;

    /**
     * @var FileMetadata
     */
    private $metadata;

    /**
     * @var array
     */
    private $stack = [];

    public function __construct($filename)
    {
        $this->filename = $filename;
    }

    /**
     * {@inheritDoc}
     *
     * Cleans up internal state
     *
     * @param array $nodes
     */
    public function beforeTraverse(array $nodes)
    {
        $this->metadata = null;
        $this->uses = [];
        $this->classes = [];
        $this->traits = [];
        $this->ast = $nodes;

        $this->stack = [
            'trait_use' => []
        ];
    }

    public function enterNode(Node $node)
    {
        if ($node instanceof Stmt\Class_ && !$node->isAnonymous()) {
            $this->stack['trait_use'] = [];
        }

        if ($node instanceof Stmt\Trait_) {
            $this->stack['trait_use'] = [];
        }

        if ($node instanceof Stmt\TraitUse) {
            $this->processTraitUse($node);
        }
    }

    public function leaveNode(Node $node)
    {
        if ($node instanceof Stmt\Class_ && !$node->isAnonymous()) {
            $name = (string) $node->namespacedName;
            $this->classes[$name] = new ClassMetadata($name, $this->getClassParentMetadata($node), $this->stack['trait_use'], $node->isFinal(), $node->isAbstract(), $this->getMethodsMetadata($node), $node);
        }

        if ($node instanceof Stmt\Trait_) {
            $name = (string) $node->namespacedName;
            $this->traits[$name] = new TraitMetadata($name, $this->stack['trait_use'], $this->getMethodsMetadata($node), $node);
        }
    }

    public function afterTraverse(array $nodes)
    {
        $this->metadata = new FileMetadata($this->filename, $this->uses, $this->classes, $this->traits, $this->ast);
    }

    /**
     * @return FileMetadata
     */
    public function getMetadata()
    {
        return $this->metadata;
    }

    /**
     * Load class parent.
     *
     * @param Stmt\Class_ $class
     *
     * @return null|ClassMetadata
     */
    private function getClassParentMetadata(Stmt\Class_ $class)
    {
        if (null !== $class->extends) {

            $name = $class->extends->toString();

            /**
             * @var FileMetadata $filemetadata
             */
            $filemetadata = MetadataLoader::create()->load($name);

            return $filemetadata->getClass($name);
        }

        return null;
    }

    private function getTraitMetadata($name)
    {
        $filemetadata = MetadataLoader::create()->load($name);
        return $filemetadata->getTraits()[$name];
    }

    /**
     * Process class methods
     *
     * @param Stmt\ClassLike $classLike
     *
     * @return MethodMetadata[]
     */
    private function getMethodsMetadata(Stmt\ClassLike $classLike)
    {
        $methods = [];

        foreach ($classLike->stmts as $stmt) {

            if ($stmt instanceof Stmt\ClassMethod) {
                $methods[] = MethodMetadata::fromClassMethod($stmt);
            }
        }

        return $methods;
    }

    /**
     * Process trait use declaration and drop on working stack.
     *
     * @param Stmt\TraitUse $node
     */
    private function processTraitUse(Stmt\TraitUse $node)
    {
        $traitMetadata = $this->getTraitMetadata((string)$node->traits[0]);

        $methods = [];

        foreach ($traitMetadata->getMethods() as $method) {
            $methods[$method->getName()] = $method;
        }

        /**
         * @var Stmt\TraitUseAdaptation\Alias $adaptation
         */
        foreach ($node->adaptations as $adaptation) {
            /**
             * @var MethodMetadata $original
             */
            $original = $methods[$adaptation->method];

            $methods[$adaptation->newName] = new MethodMetadata(
                $adaptation->newName,
                $original->isAbstract(),
                $original->isFinal(),
                MethodUtils::getVisibility($adaptation->newModifier, $original->getVisibility()),
                $original->getReturnType(),
                $original->byReference(),
                $original->isStatic(),
                $original->getParameters(),
                $original->getAst()
            );

            unset($methods[$original->getName()]);
        }

        $this->stack['trait_use'][] = new TraitMetadata($traitMetadata->getName(), $traitMetadata->getTraits(), $methods, $traitMetadata->getAst());
    }
}



1		<?php
2
3		namespace RunOpenCode\AbstractBuilder\Ast\Visitor;
4
5		use PhpParser\Node;
6		use PhpParser\NodeVisitorAbstract;
7		use PhpParser\Node\Stmt;
8		use RunOpenCode\AbstractBuilder\Ast\Metadata\ClassMetadata;
9		use RunOpenCode\AbstractBuilder\Ast\Metadata\FileMetadata;
10		use RunOpenCode\AbstractBuilder\Ast\Metadata\MethodMetadata;
11		use RunOpenCode\AbstractBuilder\Ast\Metadata\TraitMetadata;
12		use RunOpenCode\AbstractBuilder\Ast\MetadataLoader;
13		use RunOpenCode\AbstractBuilder\Utils\MethodUtils;
14
15		/**
16		* Class FileMetadataIntrospectionVisitor
17		*
18		* @package RunOpenCode\AbstractBuilder\Ast\Visitor
19		*/
20		class FileMetadataIntrospectionVisitor extends NodeVisitorAbstract
21		{
22		/**
23		* @var string
24		*/
25		private $filename;
26
27		/**
28		* @var array
29		*/
30		private $uses;
31
32		/**
33		* @var ClassMetadata[]
34		*/
35		private $classes;
36
37		/**
38		* @var TraitMetadata[]
39		*/
40		private $traits;
41
42		/**
43		* @var array
44		*/
45		private $ast;
46
47		/**
48		* @var FileMetadata
49		*/
50		private $metadata;
51
52		/**
53		* @var array
54		*/
55		private $stack = [];
56
57	3	public function __construct($filename)
58		{
59	3	$this->filename = $filename;
60	3	}
61
62		/**
63		* {@inheritDoc}
64		*
65		* Cleans up internal state
66		*
67		* @param array $nodes
68		*/
69	2	public function beforeTraverse(array $nodes)
70		{
71	2	$this->metadata = null;
72	2	$this->uses = [];
73	2	$this->classes = [];
74	2	$this->traits = [];
75	2	$this->ast = $nodes;
76
77	2	$this->stack = [
78		'trait_use' => []
79		];
80	2	}
81
82	2	public function enterNode(Node $node)
83		{
84	2	if ($node instanceof Stmt\Class_ && !$node->isAnonymous()) {
85	2	$this->stack['trait_use'] = [];
86		}
87
88	2	if ($node instanceof Stmt\Trait_) {
89		$this->stack['trait_use'] = [];
90		}
91
92	2	if ($node instanceof Stmt\TraitUse) {
93		$this->processTraitUse($node);
94		}
95	2	}
96
97	2	public function leaveNode(Node $node)
98		{
99	2	if ($node instanceof Stmt\Class_ && !$node->isAnonymous()) {
100	2	$name = (string) $node->namespacedName;
101	2	$this->classes[$name] = new ClassMetadata($name, $this->getClassParentMetadata($node), $this->stack['trait_use'], $node->isFinal(), $node->isAbstract(), $this->getMethodsMetadata($node), $node);
102		}
103
104	2	if ($node instanceof Stmt\Trait_) {
105		$name = (string) $node->namespacedName;
106		$this->traits[$name] = new TraitMetadata($name, $this->stack['trait_use'], $this->getMethodsMetadata($node), $node);
107		}
108	2	}
109
110	2	public function afterTraverse(array $nodes)
111		{
112	2	$this->metadata = new FileMetadata($this->filename, $this->uses, $this->classes, $this->traits, $this->ast);
113	2	}
114
115		/**
116		* @return FileMetadata
117		*/
118	2	public function getMetadata()
119		{
120	2	return $this->metadata;
121		}
122
123		/**
124		* Load class parent.
125		*
126		* @param Stmt\Class_ $class
127		*
128		* @return null\|ClassMetadata
129		*/
130	2	private function getClassParentMetadata(Stmt\Class_ $class)
131		{
132	2	if (null !== $class->extends) {
133
134		$name = $class->extends->toString();
135
136		/**
137		* @var FileMetadata $filemetadata
138		*/
139		$filemetadata = MetadataLoader::create()->load($name);
140
141		return $filemetadata->getClass($name);
142		}
143
144	2	return null;
145		}
146
147		private function getTraitMetadata($name)
148		{
149		$filemetadata = MetadataLoader::create()->load($name);
150		return $filemetadata->getTraits()[$name];
151		}
152
153		/**
154		* Process class methods
155		*
156		* @param Stmt\ClassLike $classLike
157		*
158		* @return MethodMetadata[]
159		*/
160	2	private function getMethodsMetadata(Stmt\ClassLike $classLike)
161		{
162	2	$methods = [];
163
164	2	foreach ($classLike->stmts as $stmt) {
165
166		if ($stmt instanceof Stmt\ClassMethod) {
167		$methods[] = MethodMetadata::fromClassMethod($stmt);
168		}
169		}
170
171	2	return $methods;
172		}
173
174		/**
175		* Process trait use declaration and drop on working stack.
176		*
177		* @param Stmt\TraitUse $node
178		*/
179		private function processTraitUse(Stmt\TraitUse $node)
180		{
181		$traitMetadata = $this->getTraitMetadata((string)$node->traits[0]);
182
183		$methods = [];
184
185		foreach ($traitMetadata->getMethods() as $method) {
186		$methods[$method->getName()] = $method;
187		}
188
189		/**
190		* @var Stmt\TraitUseAdaptation\Alias $adaptation
191		*/
192		foreach ($node->adaptations as $adaptation) {
193		/**
194		* @var MethodMetadata $original
195		*/
196		$original = $methods[$adaptation->method];
197
198		$methods[$adaptation->newName] = new MethodMetadata(
199		$adaptation->newName,
200		$original->isAbstract(),
201		$original->isFinal(),
202		MethodUtils::getVisibility($adaptation->newModifier, $original->getVisibility()),
203		$original->getReturnType(),
204		$original->byReference(),
205		$original->isStatic(),
206		$original->getParameters(),
207		$original->getAst()
208		);
209
210		unset($methods[$original->getName()]);
211		}
212
213		$this->stack['trait_use'][] = new TraitMetadata($traitMetadata->getName(), $traitMetadata->getTraits(), $methods, $traitMetadata->getAst());
214		}
215		}
216
217

RunOpenCode / abstract-builder

FileMetadataIntrospectionVisitor::afterTraverse() A last analyzed 2017-07-09 08:12 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

FileMetadataIntrospectionVisitor::afterTraverse() A
last analyzed 2017-07-09 08:12 UTC