Kint_SourceParser::getFunctionCalls() - Code Metrics - Inspection of "Merge pull request #546 from geekwright/xmf1.2.12" - XOOPS/XoopsCore25 - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b8ca50...9cbf56 )

by Michael

created 2017-11-13 03:09 UTC

Kint_SourceParser::getFunctionCalls() D

↳ Parent: Kint_SourceParser

Complexity

Conditions	51
Paths	48

Size

Total Lines	240
Code Lines	145

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	51
eloc	145
nc	48
nop	3
dl	0
loc	240
rs	4.1818
c	0
b	0
f	0

How to fix Long Method Complexity

<?php

class Kint_SourceParser
{
    private static $ignore = array(
        T_CLOSE_TAG => true,
        T_COMMENT => true,
        T_DOC_COMMENT => true,
        T_INLINE_HTML => true,
        T_OPEN_TAG => true,
        T_OPEN_TAG_WITH_ECHO => true,
        T_WHITESPACE => true,
    );

    /**
     * Things we need to do specially for operator tokens:
     * - Refuse to strip spaces around them
     * - Wrap the access path in parentheses if there
     *   are any of these in the final short parameter.
     */
    private static $operator = array(
        T_AND_EQUAL => true,
        T_BOOLEAN_AND => true,
        T_BOOLEAN_OR => true,
        T_ARRAY_CAST => true,
        T_BOOL_CAST => true,
        T_CLONE => true,
        T_CONCAT_EQUAL => true,
        T_DEC => true,
        T_DIV_EQUAL => true,
        T_DOUBLE_CAST => true,
        T_INC => true,
        T_INCLUDE => true,
        T_INCLUDE_ONCE => true,
        T_INSTANCEOF => true,
        T_INT_CAST => true,
        T_IS_EQUAL => true,
        T_IS_GREATER_OR_EQUAL => true,
        T_IS_IDENTICAL => true,
        T_IS_NOT_EQUAL => true,
        T_IS_NOT_IDENTICAL => true,
        T_IS_SMALLER_OR_EQUAL => true,
        T_LOGICAL_AND => true,
        T_LOGICAL_OR => true,
        T_LOGICAL_XOR => true,
        T_MINUS_EQUAL => true,
        T_MOD_EQUAL => true,
        T_MUL_EQUAL => true,
        T_NEW => true,
        T_OBJECT_CAST => true,
        T_OR_EQUAL => true,
        T_PLUS_EQUAL => true,
        T_REQUIRE => true,
        T_REQUIRE_ONCE => true,
        T_SL => true,
        T_SL_EQUAL => true,
        T_SR => true,
        T_SR_EQUAL => true,
        T_STRING_CAST => true,
        T_UNSET_CAST => true,
        T_XOR_EQUAL => true,
        '!' => true,
        '%' => true,
        '&' => true,
        '*' => true,
        '+' => true,
        '-' => true,
        '.' => true,
        '/' => true,
        ':' => true,
        '<' => true,
        '=' => true,
        '>' => true,
        '?' => true,
        '^' => true,
        '|' => true,
        '~' => true,
    );

    private static $strip = array(
        '(' => true,
        ')' => true,
        '[' => true,
        ']' => true,
        '{' => true,
        '}' => true,
        T_OBJECT_OPERATOR => true,
        T_DOUBLE_COLON => true,
    );

    public static function getFunctionCalls($source, $line, $function)
    {
        static $up = array(
            '(' => true,
            '[' => true,
            '{' => true,
            T_CURLY_OPEN => true,
            T_DOLLAR_OPEN_CURLY_BRACES => true,
        );
        static $down = array(
            ')' => true,
            ']' => true,
            '}' => true,
        );
        static $modifiers = array(
            '!',
            '@',
            '~',
            '+',
            '-',
        );

        if (KINT_PHP53) {
            self::$strip[T_NS_SEPARATOR] = true;
        }

        if (KINT_PHP56) {
            self::$operator[T_POW] = true;
            self::$operator[T_POW_EQUAL] = true;
        }

        if (KINT_PHP70) {
            self::$operator[T_SPACESHIP] = true;
        }

        $tokens = token_get_all($source);
        $cursor = 1;
        $function_calls = array();
        $prev_tokens = array(null, null, null);

        if (is_array($function)) {
            $class = explode('\\', $function[0]);
            $class = strtolower(end($class));
            $function = strtolower($function[1]);
        } else {
            $class = null;
            $function = strtolower($function);
        }

        // Loop through tokens
        foreach ($tokens as $index => $token) {
            if (!is_array($token)) {
                continue;
            }

            // Count newlines for line number instead of using
            // $token[2] since it's not available until 5.2.2
            // Also note that certain situations (String tokens after whitespace)
            // may not have the correct line number unless you do this manually
            $cursor += substr_count($token[1], "\n");
            if ($cursor > $line) {
                break;
            }

            // Store the last real tokens for later
            if (isset(self::$ignore[$token[0]])) {
                continue;
            } else {
                $prev_tokens = array($prev_tokens[1], $prev_tokens[2], $token);
            }

            // Check if it's the right type to be the function we're looking for
            if ($token[0] !== T_STRING || strtolower($token[1]) !== $function) {
                continue;
            }

            // Check if it's a function call
            if ($tokens[self::realTokenIndex($tokens, $index, 1)] !== '(') {
                continue;
            }

            // Check if it matches the signature
            if ($class === null) {
                if ($prev_tokens[1] && in_array($prev_tokens[1][0], array(T_DOUBLE_COLON, T_OBJECT_OPERATOR))) {
                    continue;
                }
            } else {
                if (!$prev_tokens[1] || $prev_tokens[1][0] !== T_DOUBLE_COLON) {
                    continue;
                }

                if (!$prev_tokens[0] || $prev_tokens[0][0] !== T_STRING || strtolower($prev_tokens[0][1]) !== $class) {
                    continue;
                }
            }

            $inner_cursor = $cursor;
            $depth = 0; // The depth respective to the function call
            $offset = 1; // The offset from the function call
            $instring = false; // Whether we're in a string or not
            $realtokens = false; // Whether the string contains anything meaningful or not
            $params = array(); // All our collected parameters
            $shortparam = array(); // The short version of the parameter
            $param_start = 1; // The distance to the start of the parameter

            // Loop through the following tokens until the function call ends
            while (isset($tokens[$index + $offset])) {
                $token = $tokens[$index + $offset];

                // Ensure that the $inner_cursor is correct and
                // that $token is either a T_ constant or a string
                if (is_array($token)) {
                    $inner_cursor += substr_count($token[1], "\n");
                }

                if (!isset(self::$ignore[$token[0]]) && !isset($down[$token[0]])) {
                    $realtokens = true;
                }

                // If it's a token that makes us to up a level, increase the depth
                if (isset($up[$token[0]])) {
                    // If this is the first paren set the start of the param to just after it
                    if ($depth === 0) {
                        $param_start = $offset + 1;
                    } elseif ($depth === 1) {
                        $shortparam[] = $token;
                        $realtokens = false;
                    }

                    ++$depth;
                } elseif (isset($down[$token[0]])) {
                    --$depth;

                    // If this brings us down to the parameter level, and we've had
                    // real tokens since going up, fill the $shortparam with an ellipsis
                    if ($depth === 1) {
                        if ($realtokens) {
                            $shortparam[] = '...';
                        }
                        $shortparam[] = $token;
                    }
                } elseif ($token[0] === '"') {
                    // Strings use the same symbol for up and down, but we can
                    // only ever be inside one string, so just use a bool for that
                    if ($instring) {
                        --$depth;
                        if ($depth === 1) {
                            $shortparam[] = '...';
                        }
                    } else {
                        ++$depth;
                    }

                    $instring = !$instring;

                    $shortparam[] = '"';
                } elseif ($depth === 1) {
                    if ($token[0] === ',') {
                        $params[] = array(
                            'full' => array_slice($tokens, $index + $param_start, $offset - $param_start),
                            'short' => $shortparam,
                        );
                        $shortparam = array();
                        $param_start = $offset + 1;
                    } elseif ($token[0] === T_CONSTANT_ENCAPSED_STRING && strlen($token[1]) > 2) {
                        $shortparam[] = $token[1][0].'...'.$token[1][0];
                    } else {
                        $shortparam[] = $token;
                    }
                }

                // Depth has dropped to 0 (So we've hit the closing paren)
                if ($depth <= 0) {
                    $params[] = array(
                        'full' => array_slice($tokens, $index + $param_start, $offset - $param_start),
                        'short' => $shortparam,
                    );

                    break;
                }

                ++$offset;
            }

            // If we're not passed (or at) the line at the end
            // of the function call, we're too early so skip it
            if ($inner_cursor < $line) {
                continue;
            }

            // Format the final output parameters
            foreach ($params as &$param) {
                $name = self::tokensFormatted($param['short']);
                $expression = false;
                foreach ($name as $token) {
                    if (self::tokenIsOperator($token)) {
                        $expression = true;
                        break;
                    }
                }

                $param = array(
                    'name' => self::tokensToString($name),
                    'path' => self::tokensToString(self::tokensTrim($param['full'])),
                    'expression' => $expression,
                );
            }

            // Get the modifiers
            $mods = array();
            --$index;

            while (isset($tokens[$index])) {
                if (isset(self::$ignore[$tokens[$index][0]])) {
                    --$index;
                    continue;
                } elseif (is_array($tokens[$index]) && empty($mods)) {
                    if ($tokens[$index][0] === T_DOUBLE_COLON || $tokens[$index][0] === T_STRING || (KINT_PHP53 && $tokens[$index][0] === T_NS_SEPARATOR)) {
                        --$index;
                        continue;
                    } else {
                        break;
                    }
                } elseif (in_array($tokens[$index][0], $modifiers)) {
                    $mods[] = $tokens[$index];
                    --$index;
                    continue;
                } else {
                    break;
                }
            }

            $function_calls[] = array(
                'parameters' => $params,
                'modifiers' => $mods,
            );
        }

        return $function_calls;
    }

    private static function realTokenIndex(array $tokens, $index, $direction)

    {
        $index += $direction;

        while (isset($tokens[$index])) {
            if (!isset(self::$ignore[$tokens[$index][0]])) {
                return $index;
            }

            $index += $direction;
        }

        return null;
    }

    /**
     * We need a separate method to check if tokens are operators because we
     * occasionally add "..." to short parameter versions. If we simply check
     * for `$token[0]` then "..." will incorrectly match the "." operator.
     *
     * @param array|string $token The token to check
     *
     * @return bool
     */
    private static function tokenIsOperator($token)
    {
        return $token !== '...' && isset(self::$operator[$token[0]]);
    }

    private static function tokensToString(array $tokens)
    {
        $out = '';

        foreach ($tokens as $token) {
            if (is_string($token)) {
                $out .= $token;
            } elseif (is_array($token)) {
                $out .= $token[1];
            }
        }

        return $out;
    }

    private static function tokensTrim(array $tokens)
    {
        foreach ($tokens as $index => $token) {
            if (isset(self::$ignore[$token[0]])) {
                unset($tokens[$index]);
            } else {
                break;
            }
        }

        $tokens = array_reverse($tokens);

        foreach ($tokens as $index => $token) {
            if (isset(self::$ignore[$token[0]])) {
                unset($tokens[$index]);
            } else {
                break;
            }
        }

        return array_reverse($tokens);
    }

    private static function tokensFormatted(array $tokens)
    {
        $space = false;

        $tokens = self::tokensTrim($tokens);

        $output = array();
        $last = null;

        foreach ($tokens as $index => $token) {
            if (isset(self::$ignore[$token[0]])) {
                if ($space) {
                    continue;
                }

                $next = $tokens[self::realTokenIndex($tokens, $index, 1)];

                if (isset(self::$strip[$last[0]]) && !self::tokenIsOperator($next)) {
                    continue;
                } elseif (isset(self::$strip[$next[0]]) && $last && !self::tokenIsOperator($last)) {
                    continue;
                }

                $token = ' ';
                $space = true;
            } else {
                $space = false;
                $last = $token;
            }

            $output[] = $token;
        }

        return $output;
    }
}


1		<?php
2
3		class Kint_SourceParser
4		{
5		private static $ignore = array(
6		T_CLOSE_TAG => true,
7		T_COMMENT => true,
8		T_DOC_COMMENT => true,
9		T_INLINE_HTML => true,
10		T_OPEN_TAG => true,
11		T_OPEN_TAG_WITH_ECHO => true,
12		T_WHITESPACE => true,
13		);
14
15		/**
16		* Things we need to do specially for operator tokens:
17		* - Refuse to strip spaces around them
18		* - Wrap the access path in parentheses if there
19		* are any of these in the final short parameter.
20		*/
21		private static $operator = array(
22		T_AND_EQUAL => true,
23		T_BOOLEAN_AND => true,
24		T_BOOLEAN_OR => true,
25		T_ARRAY_CAST => true,
26		T_BOOL_CAST => true,
27		T_CLONE => true,
28		T_CONCAT_EQUAL => true,
29		T_DEC => true,
30		T_DIV_EQUAL => true,
31		T_DOUBLE_CAST => true,
32		T_INC => true,
33		T_INCLUDE => true,
34		T_INCLUDE_ONCE => true,
35		T_INSTANCEOF => true,
36		T_INT_CAST => true,
37		T_IS_EQUAL => true,
38		T_IS_GREATER_OR_EQUAL => true,
39		T_IS_IDENTICAL => true,
40		T_IS_NOT_EQUAL => true,
41		T_IS_NOT_IDENTICAL => true,
42		T_IS_SMALLER_OR_EQUAL => true,
43		T_LOGICAL_AND => true,
44		T_LOGICAL_OR => true,
45		T_LOGICAL_XOR => true,
46		T_MINUS_EQUAL => true,
47		T_MOD_EQUAL => true,
48		T_MUL_EQUAL => true,
49		T_NEW => true,
50		T_OBJECT_CAST => true,
51		T_OR_EQUAL => true,
52		T_PLUS_EQUAL => true,
53		T_REQUIRE => true,
54		T_REQUIRE_ONCE => true,
55		T_SL => true,
56		T_SL_EQUAL => true,
57		T_SR => true,
58		T_SR_EQUAL => true,
59		T_STRING_CAST => true,
60		T_UNSET_CAST => true,
61		T_XOR_EQUAL => true,
62		'!' => true,
63		'%' => true,
64		'&' => true,
65		'*' => true,
66		'+' => true,
67		'-' => true,
68		'.' => true,
69		'/' => true,
70		':' => true,
71		'<' => true,
72		'=' => true,
73		'>' => true,
74		'?' => true,
75		'^' => true,
76		'\|' => true,
77		'~' => true,
78		);
79
80		private static $strip = array(
81		'(' => true,
82		')' => true,
83		'[' => true,
84		']' => true,
85		'{' => true,
86		'}' => true,
87		T_OBJECT_OPERATOR => true,
88		T_DOUBLE_COLON => true,
89		);
90
91		public static function getFunctionCalls($source, $line, $function)
92		{
93		static $up = array(
94		'(' => true,
95		'[' => true,
96		'{' => true,
97		T_CURLY_OPEN => true,
98		T_DOLLAR_OPEN_CURLY_BRACES => true,
99		);
100		static $down = array(
101		')' => true,
102		']' => true,
103		'}' => true,
104		);
105		static $modifiers = array(
106		'!',
107		'@',
108		'~',
109		'+',
110		'-',
111		);
112
113		if (KINT_PHP53) {
114		self::$strip[T_NS_SEPARATOR] = true;
115		}
116
117		if (KINT_PHP56) {
118		self::$operator[T_POW] = true;
119		self::$operator[T_POW_EQUAL] = true;
120		}
121
122		if (KINT_PHP70) {
123		self::$operator[T_SPACESHIP] = true;
124		}
125
126		$tokens = token_get_all($source);
127		$cursor = 1;
128		$function_calls = array();
129		$prev_tokens = array(null, null, null);
130
131		if (is_array($function)) {
132		$class = explode('\\', $function[0]);
133		$class = strtolower(end($class));
134		$function = strtolower($function[1]);
135		} else {
136		$class = null;
137		$function = strtolower($function);
138		}
139
140		// Loop through tokens
141		foreach ($tokens as $index => $token) {
142		if (!is_array($token)) {
143		continue;
144		}
145
146		// Count newlines for line number instead of using
147		// $token[2] since it's not available until 5.2.2
148		// Also note that certain situations (String tokens after whitespace)
149		// may not have the correct line number unless you do this manually
150		$cursor += substr_count($token[1], "\n");
151		if ($cursor > $line) {
152		break;
153		}
154
155		// Store the last real tokens for later
156		if (isset(self::$ignore[$token[0]])) {
157		continue;
158		} else {
159		$prev_tokens = array($prev_tokens[1], $prev_tokens[2], $token);
160		}
161
162		// Check if it's the right type to be the function we're looking for
163		if ($token[0] !== T_STRING \|\| strtolower($token[1]) !== $function) {
164		continue;
165		}
166
167		// Check if it's a function call
168		if ($tokens[self::realTokenIndex($tokens, $index, 1)] !== '(') {
169		continue;
170		}
171
172		// Check if it matches the signature
173		if ($class === null) {
174		if ($prev_tokens[1] && in_array($prev_tokens[1][0], array(T_DOUBLE_COLON, T_OBJECT_OPERATOR))) {
175		continue;
176		}
177		} else {
178		if (!$prev_tokens[1] \|\| $prev_tokens[1][0] !== T_DOUBLE_COLON) {
179		continue;
180		}
181
182		if (!$prev_tokens[0] \|\| $prev_tokens[0][0] !== T_STRING \|\| strtolower($prev_tokens[0][1]) !== $class) {
183		continue;
184		}
185		}
186
187		$inner_cursor = $cursor;
188		$depth = 0; // The depth respective to the function call
189		$offset = 1; // The offset from the function call
190		$instring = false; // Whether we're in a string or not
191		$realtokens = false; // Whether the string contains anything meaningful or not
192		$params = array(); // All our collected parameters
193		$shortparam = array(); // The short version of the parameter
194		$param_start = 1; // The distance to the start of the parameter
195
196		// Loop through the following tokens until the function call ends
197		while (isset($tokens[$index + $offset])) {
198		$token = $tokens[$index + $offset];
199
200		// Ensure that the $inner_cursor is correct and
201		// that $token is either a T_ constant or a string
202		if (is_array($token)) {
203		$inner_cursor += substr_count($token[1], "\n");
204		}
205
206		if (!isset(self::$ignore[$token[0]]) && !isset($down[$token[0]])) {
207		$realtokens = true;
208		}
209
210		// If it's a token that makes us to up a level, increase the depth
211		if (isset($up[$token[0]])) {
212		// If this is the first paren set the start of the param to just after it
213		if ($depth === 0) {
214		$param_start = $offset + 1;
215		} elseif ($depth === 1) {
216		$shortparam[] = $token;
217		$realtokens = false;
218		}
219
220		++$depth;
221		} elseif (isset($down[$token[0]])) {
222		--$depth;
223
224		// If this brings us down to the parameter level, and we've had
225		// real tokens since going up, fill the $shortparam with an ellipsis
226		if ($depth === 1) {
227		if ($realtokens) {
228		$shortparam[] = '...';
229		}
230		$shortparam[] = $token;
231		}
232		} elseif ($token[0] === '"') {
233		// Strings use the same symbol for up and down, but we can
234		// only ever be inside one string, so just use a bool for that
235		if ($instring) {
236		--$depth;
237		if ($depth === 1) {
238		$shortparam[] = '...';
239		}
240		} else {
241		++$depth;
242		}
243
244		$instring = !$instring;
245
246		$shortparam[] = '"';
247		} elseif ($depth === 1) {
248		if ($token[0] === ',') {
249		$params[] = array(
250		'full' => array_slice($tokens, $index + $param_start, $offset - $param_start),
251		'short' => $shortparam,
252		);
253		$shortparam = array();
254		$param_start = $offset + 1;
255		} elseif ($token[0] === T_CONSTANT_ENCAPSED_STRING && strlen($token[1]) > 2) {
256		$shortparam[] = $token[1][0].'...'.$token[1][0];
257		} else {
258		$shortparam[] = $token;
259		}
260		}
261
262		// Depth has dropped to 0 (So we've hit the closing paren)
263		if ($depth <= 0) {
264		$params[] = array(
265		'full' => array_slice($tokens, $index + $param_start, $offset - $param_start),
266		'short' => $shortparam,
267		);
268
269		break;
270		}
271
272		++$offset;
273		}
274
275		// If we're not passed (or at) the line at the end
276		// of the function call, we're too early so skip it
277		if ($inner_cursor < $line) {
278		continue;
279		}
280
281		// Format the final output parameters
282		foreach ($params as &$param) {
283		$name = self::tokensFormatted($param['short']);
284		$expression = false;
285		foreach ($name as $token) {
286		if (self::tokenIsOperator($token)) {
287		$expression = true;
288		break;
289		}
290		}
291
292		$param = array(
293		'name' => self::tokensToString($name),
294		'path' => self::tokensToString(self::tokensTrim($param['full'])),
295		'expression' => $expression,
296		);
297		}
298
299		// Get the modifiers
300		$mods = array();
301		--$index;
302
303		while (isset($tokens[$index])) {
304		if (isset(self::$ignore[$tokens[$index][0]])) {
305		--$index;
306		continue;
307		} elseif (is_array($tokens[$index]) && empty($mods)) {
308		if ($tokens[$index][0] === T_DOUBLE_COLON \|\| $tokens[$index][0] === T_STRING \|\| (KINT_PHP53 && $tokens[$index][0] === T_NS_SEPARATOR)) {
309		--$index;
310		continue;
311		} else {
312		break;
313		}
314		} elseif (in_array($tokens[$index][0], $modifiers)) {
315		$mods[] = $tokens[$index];
316		--$index;
317		continue;
318		} else {
319		break;
320		}
321		}
322
323		$function_calls[] = array(
324		'parameters' => $params,
325		'modifiers' => $mods,
326		);
327		}
328
329		return $function_calls;
330		}
331
332		private static function realTokenIndex(array $tokens, $index, $direction)
		0 ignored issues – show Documentation introduced 2017-11-13 03:03 UTC by Report Bug Copy Issue Report The return type could not be reliably inferred; please add a `@return` annotation. Our type inference engine in quite powerful, but sometimes the code does not provide enough clues to go by. In these cases we request you to add a `@return` annotation as described here. Loading history...
333		{
334		$index += $direction;
335
336		while (isset($tokens[$index])) {
337		if (!isset(self::$ignore[$tokens[$index][0]])) {
338		return $index;
339		}
340
341		$index += $direction;
342		}
343
344		return null;
345		}
346
347		/**
348		* We need a separate method to check if tokens are operators because we
349		* occasionally add "..." to short parameter versions. If we simply check
350		* for `$token[0]` then "..." will incorrectly match the "." operator.
351		*
352		* @param array\|string $token The token to check
353		*
354		* @return bool
355		*/
356		private static function tokenIsOperator($token)
357		{
358		return $token !== '...' && isset(self::$operator[$token[0]]);
359		}
360
361		private static function tokensToString(array $tokens)
362		{
363		$out = '';
364
365		foreach ($tokens as $token) {
366		if (is_string($token)) {
367		$out .= $token;
368		} elseif (is_array($token)) {
369		$out .= $token[1];
370		}
371		}
372
373		return $out;
374		}
375
376		private static function tokensTrim(array $tokens)
377		{
378	View Code Duplication	foreach ($tokens as $index => $token) {
379		if (isset(self::$ignore[$token[0]])) {
380		unset($tokens[$index]);
381		} else {
382		break;
383		}
384		}
385
386		$tokens = array_reverse($tokens);
387
388	View Code Duplication	foreach ($tokens as $index => $token) {
389		if (isset(self::$ignore[$token[0]])) {
390		unset($tokens[$index]);
391		} else {
392		break;
393		}
394		}
395
396		return array_reverse($tokens);
397		}
398
399		private static function tokensFormatted(array $tokens)
400		{
401		$space = false;
402
403		$tokens = self::tokensTrim($tokens);
404
405		$output = array();
406		$last = null;
407
408		foreach ($tokens as $index => $token) {
409		if (isset(self::$ignore[$token[0]])) {
410		if ($space) {
411		continue;
412		}
413
414		$next = $tokens[self::realTokenIndex($tokens, $index, 1)];
415
416		if (isset(self::$strip[$last[0]]) && !self::tokenIsOperator($next)) {
417		continue;
418		} elseif (isset(self::$strip[$next[0]]) && $last && !self::tokenIsOperator($last)) {
419		continue;
420		}
421
422		$token = ' ';
423		$space = true;
424		} else {
425		$space = false;
426		$last = $token;
427		}
428
429		$output[] = $token;
430		}
431
432		return $output;
433		}
434		}
435

XOOPS / XoopsCore25

Push — master ( b8ca50...9cbf56 )

Kint_SourceParser::getFunctionCalls() D

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like