ReflectionClassUse::next() - Code Metrics - Speicher210/Reflection - Measure and Improve Code Quality continuously with Scrutinizer

ReflectionClassUse::next() B
last analyzed 2017-02-15 09:14 UTC

↳ Parent: ReflectionClassUse

Complexity

Conditions	5
Paths	3

Size

Total Lines	13
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	5

Importance

Changes

Metric	Value
dl	0
loc	13
ccs	7
cts	7
cp	1
rs	8.8571
c	0
b	0
f	0
cc	5
eloc	7
nc	3
nop	1
crap	5

<?php

namespace Wingu\OctopusCore\Reflection;

use Wingu\OctopusCore\Reflection\Exceptions\InvalidArgumentException;

/**
 * Reflection about a class use statement.
 */
class ReflectionClassUse implements \Reflector
{

    /**
     * The name of the trait.
     *
     * @var string
     */
    protected $name;

    /**
     * The conflict resolutions of the trait.
     *
     * @var array
     */
    private $conflictResolutions = array();

    /**
     * The class where the use statement has been declared.
     *
     * @var \Wingu\OctopusCore\Reflection\ReflectionClass
     */
    protected $declaringClass;

    /**
     * The tokens list of the parsed PHP code.
     *
     * @var array
     */
    private $tokens = array();

    /**
     * The number of tokens found in the code.
     *
     * @var integer
     */
    private $tokensCount = 0;

    /**
     * The current token position.
     *
     * @var integer
     */
    private $tokenPos = 0;

    /**
     * Constructor.
     *
     * @param string $class The class name where the use statement is defined.
     * @param string $name The name of the trait.
     */
    public function __construct($class, $name)
    {
        $this->declaringClass = new ReflectionClass($class);
        $this->name = $name;

        $this->findConflictResolutions();
        $this->tokens = array();
        $this->tokensCount = $this->tokenPos = 0;
    }

    /**
     * Get the name of the trait.
     *
     * @return string
     */
    public function getName()
    {
        return $this->name;
    }

    /**
     * Get the conflict resolutions.
     *
     * @return array
     */
    public function getConflictResolutions()
    {
        return $this->conflictResolutions;
    }

    /**
     * Find the conflict resolutions of a trait.
     *
     * @throws \Wingu\OctopusCore\Reflection\Annotation\Exceptions\InvalidArgumentException If the trait is not found.
     */
    protected function findConflictResolutions()
    {
        $contents = '<?php' . PHP_EOL . $this->declaringClass->getBody();
        $this->tokens = token_get_all($contents);
        $this->tokensCount = count($this->tokens);

        while (($token = $this->next()) !== null) {
            if ($token[0] === T_USE) {
                $conflicts = $this->extractConflictsFromUseStatement();
                if ($conflicts !== null) {
                    $this->conflictResolutions = explode(';', implode('', $conflicts));
                    $this->conflictResolutions = array_map('trim', $this->conflictResolutions);
                    $this->conflictResolutions = array_filter($this->conflictResolutions);

                    return;
                }
            }
        }

        throw new InvalidArgumentException('Could not find the trait "' . $this->name . '".');
    }

    /**
     * Extract the conflicts from the current use statement.
     *
     * @return array
     */
    private function extractConflictsFromUseStatement()
    {
        $class = '';
        $conflicts = array();
        $inConflicts = false;
        while (($token = $this->next($inConflicts)) !== null) {
            if ($token !== '}' && $inConflicts === true) {
                if (is_string($token) === true) {
                    $conflicts[] = trim($token);
                } else {
                    $conflicts[] = $token[1];
                }

                continue;
            }

            if (($token[0] === T_STRING || $token[0] === T_NS_SEPARATOR) === true) {
                $class .= $token[1];
            } else {
                if ($token === ',') {
                    if ($this->isSearchedTrait($class) === true) {
                        return $conflicts;
                    }

                    $class = '';
                } else {
                    if ($token === ';') {
                        if ($this->isSearchedTrait($class) === true) {
                            return $conflicts;
                        } else {
                            return null;
                        }
                    } else {
                        if ($token === '{') {
                            $inConflicts = true;
                        } else {
                            if ($token === '}') {
                                if ($this->isSearchedTrait($class) === true) {
                                    return $conflicts;
                                } else {
                                    return null;
                                }
                            } else {
                                break;
                            }
                        }
                    }
                }
            }
        }

        return null;
    }

    /**
     * Check if the found trait name is the one that we need to reflect.
     *
     * @param string $name The name of the trait found.
     * @return boolean
     */
    private function isSearchedTrait($name)
    {
        if ($this->name === $name) {
            return true;
        }

        if (strpos($name, '\\') === 0) {
            return $this->name === $name || '\\' . $this->name === $name;
        }

        $name = $this->declaringClass->getNamespaceName() . '\\' . $name;

        return $this->name === $name || $this->name === '\\' . $name;
    }

    /**
     * Return the next token that is not a whitespace or comment.
     *
     * @param boolean $includeWhiteSpace Flag if the whitespace should also be returned.
     * @return mixed
     */
    private function next($includeWhiteSpace = false)
    {
        for ($i = $this->tokenPos; $i < $this->tokensCount; $i++) {
            $this->tokenPos++;
            if (($includeWhiteSpace === false && $this->tokens[$i][0] === T_WHITESPACE) || $this->tokens[$i][0] === T_COMMENT) {
                continue;
            }

            return $this->tokens[$i];
        }

        return null;
    }

    /**
     * Export the current use statement reflection.
     *
     * @param string $className The class name where the use statement is defined.
     * @param string $name The name of the trait.
     * @param boolean $return Flag if the export should be returned or not.
     * @return string
     */
    public static function export($className, $name, $return = false)
    {
        $export = new self($className, $name);
        $export = (string)$export;
        if ($return === true) {
            return $export;
        } else {
            echo $export;

            return null;
        }
    }

    /**
     * Return the string representation of the ReflectionConstant object.
     *
     * @return string
     */
    public function __toString()
    {
        $return = 'ClassUse [ trait ' . $this->name . ' ]';
        if (count($this->conflictResolutions) > 0) {
            return $return . ' {' . PHP_EOL . implode(';' . PHP_EOL, $this->conflictResolutions) . ';' . PHP_EOL . '}';
        } else {
            return $return . ' { }';
        }
    }
}


1		<?php
2
3		namespace Wingu\OctopusCore\Reflection;
4
5		use Wingu\OctopusCore\Reflection\Exceptions\InvalidArgumentException;
6
7		/**
8		* Reflection about a class use statement.
9		*/
10		class ReflectionClassUse implements \Reflector
11		{
12
13		/**
14		* The name of the trait.
15		*
16		* @var string
17		*/
18		protected $name;
19
20		/**
21		* The conflict resolutions of the trait.
22		*
23		* @var array
24		*/
25		private $conflictResolutions = array();
26
27		/**
28		* The class where the use statement has been declared.
29		*
30		* @var \Wingu\OctopusCore\Reflection\ReflectionClass
31		*/
32		protected $declaringClass;
33
34		/**
35		* The tokens list of the parsed PHP code.
36		*
37		* @var array
38		*/
39		private $tokens = array();
40
41		/**
42		* The number of tokens found in the code.
43		*
44		* @var integer
45		*/
46		private $tokensCount = 0;
47
48		/**
49		* The current token position.
50		*
51		* @var integer
52		*/
53		private $tokenPos = 0;
54
55		/**
56		* Constructor.
57		*
58		* @param string $class The class name where the use statement is defined.
59		* @param string $name The name of the trait.
60		*/
61	36	public function __construct($class, $name)
62		{
63	36	$this->declaringClass = new ReflectionClass($class);
64	36	$this->name = $name;
65
66	36	$this->findConflictResolutions();
67	33	$this->tokens = array();
68	33	$this->tokensCount = $this->tokenPos = 0;
69	33	}
70
71		/**
72		* Get the name of the trait.
73		*
74		* @return string
75		*/
76	24	public function getName()
77		{
78	24	return $this->name;
79		}
80
81		/**
82		* Get the conflict resolutions.
83		*
84		* @return array
85		*/
86	24	public function getConflictResolutions()
87		{
88	24	return $this->conflictResolutions;
89		}
90
91		/**
92		* Find the conflict resolutions of a trait.
93		*
94		* @throws \Wingu\OctopusCore\Reflection\Annotation\Exceptions\InvalidArgumentException If the trait is not found.
95		*/
96	39	protected function findConflictResolutions()
97		{
98	39	$contents = '<?php' . PHP_EOL . $this->declaringClass->getBody();
99	39	$this->tokens = token_get_all($contents);
100	39	$this->tokensCount = count($this->tokens);
101
102	39	while (($token = $this->next()) !== null) {
103	39	if ($token[0] === T_USE) {
104	39	$conflicts = $this->extractConflictsFromUseStatement();
105	39	if ($conflicts !== null) {
106	33	$this->conflictResolutions = explode(';', implode('', $conflicts));
107	33	$this->conflictResolutions = array_map('trim', $this->conflictResolutions);
108	33	$this->conflictResolutions = array_filter($this->conflictResolutions);
109
110	33	return;
111		}
112	8	}
113	13	}
114
115	6	throw new InvalidArgumentException('Could not find the trait "' . $this->name . '".');
116		}
117
118		/**
119		* Extract the conflicts from the current use statement.
120		*
121		* @return array
122		*/
123	39	private function extractConflictsFromUseStatement()
124		{
125	39	$class = '';
126	39	$conflicts = array();
127	39	$inConflicts = false;
128	39	while (($token = $this->next($inConflicts)) !== null) {
129	39	if ($token !== '}' && $inConflicts === true) {
130	15	if (is_string($token) === true) {
131	15	$conflicts[] = trim($token);
132	5	} else {
133	15	$conflicts[] = $token[1];
134		}
135
136	15	continue;
137		}
138
139	39	if (($token[0] === T_STRING \|\| $token[0] === T_NS_SEPARATOR) === true) {
140	36	$class .= $token[1];
141	12	} else {
142	39	if ($token === ',') {
143	33	if ($this->isSearchedTrait($class) === true) {
144	9	return $conflicts;
145		}
146
147	24	$class = '';
148	8	} else {
149	30	if ($token === ';') {
150	24	if ($this->isSearchedTrait($class) === true) {
151	15	return $conflicts;
152		} else {
153	21	return null;
154		}
155		} else {
156	18	if ($token === '{') {
157	15	$inConflicts = true;
158	5	} else {
159	18	if ($token === '}') {
160	15	if ($this->isSearchedTrait($class) === true) {
161	9	return $conflicts;
162		} else {
163	6	return null;
164		}
165		} else {
166	3	break;
167		}
168		}
169		}
170		}
171		}
172	12	}
173
174	3	return null;
175		}
176
177		/**
178		* Check if the found trait name is the one that we need to reflect.
179		*
180		* @param string $name The name of the trait found.
181		* @return boolean
182		*/
183	36	private function isSearchedTrait($name)
184		{
185	36	if ($this->name === $name) {
186	6	return true;
187		}
188
189	36	if (strpos($name, '\\') === 0) {
190	12	return $this->name === $name \|\| '\\' . $this->name === $name;
191		}
192
193	36	$name = $this->declaringClass->getNamespaceName() . '\\' . $name;
194
195	36	return $this->name === $name \|\| $this->name === '\\' . $name;
196		}
197
198		/**
199		* Return the next token that is not a whitespace or comment.
200		*
201		* @param boolean $includeWhiteSpace Flag if the whitespace should also be returned.
202		* @return mixed
203		*/
204	39	private function next($includeWhiteSpace = false)
205		{
206	39	for ($i = $this->tokenPos; $i < $this->tokensCount; $i++) {
207	39	$this->tokenPos++;
208	39	if (($includeWhiteSpace === false && $this->tokens[$i][0] === T_WHITESPACE) \|\| $this->tokens[$i][0] === T_COMMENT) {
209	39	continue;
210		}
211
212	39	return $this->tokens[$i];
213		}
214
215	6	return null;
216		}
217
218		/**
219		* Export the current use statement reflection.
220		*
221		* @param string $className The class name where the use statement is defined.
222		* @param string $name The name of the trait.
223		* @param boolean $return Flag if the export should be returned or not.
224		* @return string
225		*/
226	9	public static function export($className, $name, $return = false)
227		{
228	9	$export = new self($className, $name);
229	9	$export = (string)$export;
230	9	if ($return === true) {
231	6	return $export;
232		} else {
233	3	echo $export;
234
235	3	return null;
236		}
237		}
238
239		/**
240		* Return the string representation of the ReflectionConstant object.
241		*
242		* @return string
243		*/
244	9	public function __toString()
245		{
246	9	$return = 'ClassUse [ trait ' . $this->name . ' ]';
247	9	if (count($this->conflictResolutions) > 0) {
248	3	return $return . ' {' . PHP_EOL . implode(';' . PHP_EOL, $this->conflictResolutions) . ';' . PHP_EOL . '}';
249		} else {
250	6	return $return . ' { }';
251		}
252		}
253		}
254

Speicher210 / Reflection

GitHub Access Token became invalid

ReflectionClassUse::next() B last analyzed 2017-02-15 09:14 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

ReflectionClassUse::next() B
last analyzed 2017-02-15 09:14 UTC