Kint::getSingleCall() - Code Metrics - Inspection of "fixup! The great Kint\Kint refactor" - jnvsor/kint - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed

Push — test ( b3915a...cbea0e )

by Jonathan

created 2018-04-22 15:28 UTC

Kint::getSingleCall() C

↳ Parent: Kint

Complexity

Conditions	13
Paths	33

Size

Total Lines	58
Code Lines	33

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	13
eloc	33
nc	33
nop	2
dl	0
loc	58
rs	6.5104
c	0
b	0
f	0

How to fix Long Method Complexity

<?php

namespace Kint;

use InvalidArgumentException;
use Kint\Object\BasicObject;
use Kint\Parser\Parser;
use Kint\Parser\Plugin;
use Kint\Renderer\Renderer;
use Kint\Renderer\TextRenderer;

class Kint

{
    /**
     * @var mixed Kint mode
     *
     * false: Disabled
     * true: Enabled, default mode selection
     * other: Manual mode selection
     */
    public static $enabled_mode = true;


    /**
     * Default mode.
     *
     * @var string
     */
    public static $mode_default = self::MODE_RICH;


    /**
     * Default mode in CLI with cli_detection on.
     *
     * @var string
     */
    public static $mode_default_cli = self::MODE_CLI;


    /**
     * @var bool Return output instead of echoing
     */
    public static $return;

    /**
     * @var string format of the link to the source file in trace entries.
     *
     * Use %f for file path, %l for line number.
     *
     * [!] EXAMPLE (works with for phpStorm and RemoteCall Plugin):
     *
     * Kint::$file_link_format = 'http://localhost:8091/?message=%f:%l';
     */
    public static $file_link_format = '';


    /**
     * @var bool whether to display where kint was called from
     */
    public static $display_called_from = true;


    /**
     * @var array base directories of your application that will be displayed instead of the full path.
     *
     * Keys are paths, values are replacement strings
     *
     * [!] EXAMPLE (for Laravel 5):
     *
     * Kint::$app_root_dirs = [
     *     base_path() => '<BASE>',
     *     app_path() => '<APP>',
     *     config_path() => '<CONFIG>',
     *     database_path() => '<DATABASE>',
     *     public_path() => '<PUBLIC>',
     *     resource_path() => '<RESOURCE>',
     *     storage_path() => '<STORAGE>',
     * ];
     *
     * Defaults to [$_SERVER['DOCUMENT_ROOT'] => '<ROOT>']
     */
    public static $app_root_dirs = array();


    /**
     * @var int max array/object levels to go deep, if zero no limits are applied
     */
    public static $max_depth = 6;


    /**
     * @var bool expand all trees by default for rich view
     */
    public static $expanded = false;

    /**
     * @var bool enable detection when Kint is command line.
     *
     * Formats output with whitespace only; does not HTML-escape it
     */
    public static $cli_detection = true;


    /**
     * @var array Kint aliases. Add debug functions in Kint wrappers here to fix modifiers and backtraces
     */
    public static $aliases = array(
        array('Kint\\Kint', 'dump'),
        array('Kint\\Kint', 'trace'),
        array('Kint\\Kint', 'dumpArray'),
    );

    /**
     * @var array Kint\Renderer\Renderer descendants. Add to array to extend.
     */
    public static $renderers = array(
        self::MODE_RICH => 'Kint\\Renderer\\RichRenderer',
        self::MODE_PLAIN => 'Kint\\Renderer\\PlainRenderer',
        self::MODE_TEXT => 'Kint\\Renderer\\TextRenderer',
        self::MODE_CLI => 'Kint\\Renderer\\CliRenderer',
    );

    const MODE_RICH = 'r';
    const MODE_TEXT = 't';
    const MODE_CLI = 'c';
    const MODE_PLAIN = 'p';

    public static $plugins = array(
        'Kint\\Parser\\ArrayObjectPlugin',
        'Kint\\Parser\\Base64Plugin',
        'Kint\\Parser\\BlacklistPlugin',
        'Kint\\Parser\\ClassMethodsPlugin',
        'Kint\\Parser\\ClassStaticsPlugin',
        'Kint\\Parser\\ClosurePlugin',
        'Kint\\Parser\\ColorPlugin',
        'Kint\\Parser\\DateTimePlugin',
        'Kint\\Parser\\FsPathPlugin',
        'Kint\\Parser\\IteratorPlugin',
        'Kint\\Parser\\JsonPlugin',
        'Kint\\Parser\\MicrotimePlugin',
        'Kint\\Parser\\SimpleXMLElementPlugin',
        'Kint\\Parser\\SplFileInfoPlugin',
        'Kint\\Parser\\SplObjectStoragePlugin',
        'Kint\\Parser\\StreamPlugin',
        'Kint\\Parser\\TablePlugin',
        'Kint\\Parser\\ThrowablePlugin',
        'Kint\\Parser\\TimestampPlugin',
        'Kint\\Parser\\ToStringPlugin',
        'Kint\\Parser\\TracePlugin',
        'Kint\\Parser\\XmlPlugin',
    );

    protected static $plugin_pool = array();


    protected $parser;
    protected $renderer;

    public function __construct(Parser $p, Renderer $r)

    {
        $this->parser = $p;
        $this->renderer = $r;
    }

    public function setParser(Parser $p)

    {
        $this->parser = $p;
    }

    public function getParser()
    {
        return $this->parser;
    }

    public function setRenderer(Renderer $r)

    {
        $this->renderer = $r;
    }

    public function getRenderer()
    {
        return $this->renderer;
    }

    public function setStatesFromStatics(array $statics)
    {
        $this->renderer->setExpand(!empty($statics['expanded']));
        $this->renderer->setReturnMode(!empty($statics['return']));
        $this->renderer->setShowTrace(!empty($statics['display_called_from']));

        $this->parser->setDepthLimit(isset($statics['max_depth']) ? $statics['max_depth'] : false);
        $this->parser->clearPlugins();

        if (!isset($statics['plugins'])) {
            return;
        }

        $plugins = array();

        foreach ($statics['plugins'] as $plugin) {
            if ($plugin instanceof Plugin) {
                $plugins[] = $plugin;
            } elseif (is_string($plugin) && is_subclass_of($plugin, 'Kint\\Parser\\Plugin')) {
                if (!isset(self::$plugin_pool[$plugin])) {
                    $p = new $plugin();
                    self::$plugin_pool[$plugin] = $p;
                }
                $plugins[] = self::$plugin_pool[$plugin];
            }
        }

        $plugins = $this->renderer->filterParserPlugins($plugins);

        foreach ($plugins as $plugin) {
            $this->parser->addPlugin($plugin);
        }
    }

    public function setStatesFromCallInfo(array $info)
    {
        $this->renderer->setCallInfo($info);

        if (isset($info['modifiers']) && is_array($info['modifiers'])) {
            if (in_array('!', $info['modifiers'])) {
                $this->renderer->setExpand(true);
            }

            if (in_array('@', $info['modifiers'])) {
                $this->renderer->setReturnMode(true);
            }

            if (in_array('+', $info['modifiers'])) {
                $this->parser->setDepthLimit(false);
            }
        }

        $this->parser->setCallerClass(isset($info['caller']['class']) ? $info['caller']['class'] : null);
    }

    /**
     * Renders a list of vars including the pre and post renders.
     *
     * @param array         $vars Data to dump
     * @param BasicObject[] $base Base objects
     *
     * @return string
     */
    public function dumpAll(array $vars, array $base)
    {
        if (array_keys($vars) !== array_keys($base)) {
            throw new InvalidArgumentException('Kint::dumpAll requires arrays of identical size and keys as arguments');
        }

        $output = $this->renderer->preRender();

        if ($vars === array()) {
            $output .= $this->renderer->renderNothing();
        }

        foreach ($vars as $key => $arg) {
            if (!$base[$key] instanceof BasicObject) {
                throw new InvalidArgumentException('Kint::dumpAll requires all elements of the second argument to be BasicObject instances');
            }
            $output .= $this->dumpVar($arg, $base[$key]);
        }

        $output .= $this->renderer->postRender();

        return $output;
    }

    /**
     * Dumps and renders a var.
     *
     * @param mixed       $var  Data to dump
     * @param BasicObject $base Base object
     *
     * @return string
     */
    public function dumpVar(&$var, BasicObject $base)
    {
        return $this->renderer->render(
            $this->parser->parse($var, $base)
        );
    }

    /**
     * Gets all static settings at once.
     *
     * @return array Current static settings
     */
    public static function getStatics()
    {
        return array(
            'aliases' => self::$aliases,
            'app_root_dirs' => self::$app_root_dirs,
            'cli_detection' => self::$cli_detection,
            'display_called_from' => self::$display_called_from,
            'enabled_mode' => self::$enabled_mode,
            'expanded' => self::$expanded,
            'file_link_format' => self::$file_link_format,
            'max_depth' => self::$max_depth,
            'mode_default' => self::$mode_default,
            'mode_default_cli' => self::$mode_default_cli,
            'plugins' => self::$plugins,
            'renderers' => self::$renderers,
            'return' => self::$return,
        );
    }

    /**
     * Creates a Kint instances based on static settings.
     *
     * Also calls setStatesFromStatics for you
     *
     * @param array $statics array of statics as returned by getStatics
     *
     * @return Kint|null
     */
    public static function createFromStatics(array $statics)
    {
        $mode = false;

        if (isset($statics['enabled_mode'])) {
            $mode = $statics['enabled_mode'];

            if ($statics['enabled_mode'] === true && isset($statics['mode_default'])) {
                $mode = $statics['mode_default'];

                if (PHP_SAPI === 'cli' && !empty($statics['cli_detection']) && isset($statics['mode_default_cli'])) {
                    $mode = $statics['mode_default_cli'];
                }
            }
        }

        if (!$mode) {
            return null;
        }

        if (!isset($statics['renderers'][$mode])) {
            $renderer = new TextRenderer();
        } else {
            $renderer = new $statics['renderers'][$mode]();
        }

        $kintstance = new self(new Parser(), $renderer);

        return $kintstance;
    }

    /**
     * Creates base objects given parameter info.
     *
     * @param array $params Parameters as returned from getCallInfo
     * @param int   $argc   Number of arguments the helper was called with
     *
     * @return BasicObject[] Base objects for the arguments
     */
    public static function getBasesFromParamInfo(array $params, $argc)
    {
        static $blacklist = array(
            'null',
            'true',
            'false',
            'array(...)',
            'array()',
            '[...]',
            '[]',
            '(...)',
            '()',
            '"..."',
            'b"..."',
            "'...'",
            "b'...'",
        );

        $params = array_values($params);

        $bases = array();

        for ($i = 0; $i < $argc; ++$i) {
            if (isset($params[$i])) {
                $param = $params[$i];
            } else {
                $param = null;
            }

            if (!isset($param['name']) || is_numeric($param['name'])) {
                $name = null;
            } elseif (in_array(strtolower($param['name']), $blacklist, true)) {
                $name = null;
            } else {
                $name = $param['name'];
            }

            if (isset($param['path'])) {
                $access_path = $param['path'];


                if (!empty($param['expression'])) {
                    $access_path = '('.$access_path.')';

                }
            } else {
                $access_path = '$'.$i;

            }

            $bases[] = BasicObject::blank($name, $access_path);

        }

        return $bases;
    }

    /**
     * Gets call info from the backtrace, alias, and argument count.
     *
     * Aliases must be normalized beforehand (Utils::normalizeAliases)
     *
     * @param array $aliases Call aliases as found in Kint::$aliases
     * @param array $trace   Backtrace
     * @param int   $argc    Number of arguments
     *
     * @return array[5] Call info

     */
    public static function getCallInfo(array $aliases, array $trace, $argc)
    {
        $found = false;
        $callee = null;
        $caller = null;
        $miniTrace = array();

        foreach ($trace as $index => $frame) {
            if (Utils::traceFrameIsListed($frame, $aliases)) {
                $found = true;
                $miniTrace = array();
            }

            if (!Utils::traceFrameIsListed($frame, array('spl_autoload_call'))) {
                $miniTrace[] = $frame;
            }
        }

        if ($found) {
            $callee = reset($miniTrace) ?: null;
            $caller = next($miniTrace) ?: null;
        }

        foreach ($miniTrace as $index => $frame) {
            if (!isset($frame['file'], $frame['line'])) {
                unset($miniTrace[$index]);
            } else {
                unset($frame['object'], $frame['args']);
                $miniTrace[$index] = $frame;
            }
        }

        $miniTrace = array_values($miniTrace);

        $call = self::getSingleCall($callee ?: array(), $argc);

        $ret = array(
            'params' => null,
            'modifiers' => array(),
            'callee' => $callee,
            'caller' => $caller,
            'trace' => $miniTrace,
        );

        if ($call) {
            $ret['params'] = $call['parameters'];
            $ret['modifiers'] = $call['modifiers'];
        }

        return $ret;
    }

    /**
     * Returns specific function call info from a stack trace frame, or null if no match could be found.
     *
     * @param array $frame The stack trace frame in question
     * @param int   $argc  The amount of arguments received
     *
     * @return array|null params and modifiers, or null if a specific call could not be determined
     */
    protected static function getSingleCall(array $frame, $argc)
    {
        if (!isset($frame['file'], $frame['line'], $frame['function']) || !is_readable($frame['file'])) {
            return null;
        }

        if (empty($frame['class'])) {
            $callfunc = $frame['function'];
        } else {
            $callfunc = array($frame['class'], $frame['function']);
        }

        $calls = CallFinder::getFunctionCalls(file_get_contents($frame['file']), $frame['line'], $callfunc);

        $return = null;

        foreach ($calls as $call) {
            $is_unpack = false;


            // Handle argument unpacking as a last resort
            if (KINT_PHP56) {
                foreach ($call['parameters'] as $i => &$param) {
                    if (strpos($param['name'], '...') === 0) {
                        if ($i === count($call['parameters']) - 1) {
                            for ($j = 1; $j + $i < $argc; ++$j) {
                                $call['parameters'][] = array(
                                    'name' => 'array_values('.substr($param['name'], 3).')['.$j.']',
                                    'path' => 'array_values('.substr($param['path'], 3).')['.$j.']',
                                    'expression' => false,
                                );
                            }

                            $param['name'] = 'reset('.substr($param['name'], 3).')';
                            $param['path'] = 'reset('.substr($param['path'], 3).')';
                            $param['expression'] = false;
                        } else {
                            $call['parameters'] = array_slice($call['parameters'], 0, $i);
                        }

                        $is_unpack = true;

                        break;
                    }
                }
            }

            if ($is_unpack || count($call['parameters']) === $argc) {

                if ($return === null) {
                    $return = $call;
                } else {
                    // If we have multiple calls on the same line with the same amount of arguments,
                    // we can't be sure which it is so just return null and let them figure it out
                    return null;
                }
            }
        }

        return $return;
    }

    /**
     * Dumps a backtrace.
     *
     * Functionally equivalent to Kint::dump(1) or Kint::dump(debug_backtrace(true))
     *
     * @return string|int
     */
    public static function trace()
    {
        $statics = self::getStatics();
        $kintstance = self::createFromStatics($statics);
        if (!$kintstance) {
            return 0;
        }

        Utils::normalizeAliases(self::$aliases);

        $args = func_get_args();

        $call_info = self::getCallInfo(self::$aliases, debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS), count($args));


        if (in_array('~', $call_info['modifiers'])) {

            $statics['enabled_mode'] = self::MODE_TEXT;
        }
        if (in_array('-', $call_info['modifiers'])) {

            while (ob_get_level()) {
                ob_end_clean();
            }
        }

        $kintstance->setStatesFromStatics($statics);
        $kintstance->setStatesFromCallInfo($call_info);


        $trimmed_trace = array();

        $trace = debug_backtrace(true);

        foreach ($trace as $frame) {
            if (Utils::traceFrameIsListed($frame, self::$aliases)) {
                $trimmed_trace = array();

            }

            $trimmed_trace[] = $frame;

        }

        $output = $kintstance->dumpAll(
            array($trimmed_trace),

            array(BasicObject::blank('Kint\\Kint::trace()', 'debug_backtrace(true)'))
        );

        if (self::$return || in_array('@', $call_info['modifiers'])) {

            return $output;
        } else {
            echo $output;

            return 0;
        }
    }

    /**
     * Dumps some data.
     *
     * Functionally equivalent to Kint::dump(1) or Kint::dump(debug_backtrace(true))
     *
     * @return string|int
     */
    public static function dump()
    {
        $statics = self::getStatics();
        $kintstance = self::createFromStatics($statics);
        if (!$kintstance) {
            return 0;
        }

        Utils::normalizeAliases(self::$aliases);

        $args = func_get_args();

        $call_info = self::getCallInfo(self::$aliases, debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS), count($args));


        if (in_array('~', $call_info['modifiers'])) {

            $statics['enabled_mode'] = self::MODE_TEXT;
        }
        if (in_array('-', $call_info['modifiers'])) {

            while (ob_get_level()) {
                ob_end_clean();
            }
        }

        $kintstance->setStatesFromStatics($statics);
        $kintstance->setStatesFromCallInfo($call_info);


        // If the call is Kint::dump(1) then dump a backtrace instead
        if ($args === array(1) && (!isset($call_info['params'][0]['name']) || $call_info['params'][0]['name'] === '1')) {

            $args = debug_backtrace(true);
            $trace = array();

            foreach ($args as $index => $frame) {
                if (Utils::traceFrameIsListed($frame, self::$aliases)) {
                    $trace = array();
                }

                $trace[] = $frame;
            }

            $tracename = $call_info['callee']['function'].'(1)';

            if (isset($call_info['callee']['class'], $call_info['callee']['type'])) {

                $tracename = $call_info['callee']['class'].$call_info['callee']['type'].$tracename;

            }
            $tracebase = BasicObject::blank($tracename, 'debug_backtrace(true)');

            $output = $kintstance->dumpAll(array($trace), array($tracebase));
        } else {
            $bases = self::getBasesFromParamInfo(
                isset($call_info['params']) ? $call_info['params'] : array(),

                count($args)
            );
            $output = $kintstance->dumpAll($args, $bases);
        }

        if (self::$return || in_array('@', $call_info['modifiers'])) {

            return $output;
        } else {
            echo $output;

            return 0;
        }
    }

    /**
     * generic path display callback, can be configured in app_root_dirs; purpose is
     * to show relevant path info and hide as much of the path as possible.
     *
     * @param string $file
     *
     * @return string
     */
    public static function shortenPath($file)
    {
        $file = array_values(array_filter(explode('/', str_replace('\\', '/', $file)), 'strlen'));


        $longest_match = 0;

        $match = '/';

        foreach (self::$app_root_dirs as $path => $alias) {
            if (empty($path)) {
                continue;
            }

            $path = array_values(array_filter(explode('/', str_replace('\\', '/', $path)), 'strlen'));

            if (array_slice($file, 0, count($path)) === $path && count($path) > $longest_match) {

                $longest_match = count($path);

                $match = $alias;
            }
        }

        if ($longest_match) {

            $file = array_merge(array($match), array_slice($file, $longest_match));


            return implode('/', $file);
        } else {
            // fallback to find common path with Kint dir
            $kint = array_values(array_filter(explode('/', str_replace('\\', '/', KINT_DIR)), 'strlen'));

            foreach ($file as $i => $part) {
                if (!isset($kint[$i]) || $kint[$i] !== $part) {
                    return ($i ? '.../' : '/').implode('/', array_slice($file, $i));
                }
            }

            return '/'.implode('/', $file);
        }
    }

    public static function getIdeLink($file, $line)
    {
        return str_replace(array('%f', '%l'), array($file, $line), self::$file_link_format);
    }
}


1			<?php
2
3			namespace Kint;
4
5			use InvalidArgumentException;
6			use Kint\Object\BasicObject;
7			use Kint\Parser\Parser;
8			use Kint\Parser\Plugin;
9			use Kint\Renderer\Renderer;
10			use Kint\Renderer\TextRenderer;
11
12			class Kint
			0 ignored issues – show Coding Style introduced 2018-04-22 14:37 UTC by Report Bug Copy Issue Report The property $enabled_mode is not named in camelCase. This check marks property names that have not been written in camelCase. In camelCase names are written without any punctuation, the start of each new word being marked by a capital letter. Thus the name database connection string becomes `databaseConnectionString`. Loading history... Coding Style introduced 2018-04-22 14:37 UTC by Report Bug Copy Issue Report The property $mode_default is not named in camelCase. This check marks property names that have not been written in camelCase. In camelCase names are written without any punctuation, the start of each new word being marked by a capital letter. Thus the name database connection string becomes `databaseConnectionString`. Loading history... Coding Style introduced 2018-04-22 14:37 UTC by Report Bug Copy Issue Report The property $mode_default_cli is not named in camelCase. This check marks property names that have not been written in camelCase. In camelCase names are written without any punctuation, the start of each new word being marked by a capital letter. Thus the name database connection string becomes `databaseConnectionString`. Loading history... Coding Style introduced 2018-04-22 14:37 UTC by Report Bug Copy Issue Report The property $file_link_format is not named in camelCase. This check marks property names that have not been written in camelCase. In camelCase names are written without any punctuation, the start of each new word being marked by a capital letter. Thus the name database connection string becomes `databaseConnectionString`. Loading history... Coding Style introduced 2018-04-22 14:37 UTC by Report Bug Copy Issue Report The property $display_called_from is not named in camelCase. This check marks property names that have not been written in camelCase. In camelCase names are written without any punctuation, the start of each new word being marked by a capital letter. Thus the name database connection string becomes `databaseConnectionString`. Loading history... Coding Style introduced 2018-04-22 14:37 UTC by Report Bug Copy Issue Report The property $app_root_dirs is not named in camelCase. This check marks property names that have not been written in camelCase. In camelCase names are written without any punctuation, the start of each new word being marked by a capital letter. Thus the name database connection string becomes `databaseConnectionString`. Loading history... Coding Style introduced 2018-04-22 14:37 UTC by Report Bug Copy Issue Report The property $max_depth is not named in camelCase. This check marks property names that have not been written in camelCase. In camelCase names are written without any punctuation, the start of each new word being marked by a capital letter. Thus the name database connection string becomes `databaseConnectionString`. Loading history... Coding Style introduced 2018-04-22 14:37 UTC by Report Bug Copy Issue Report The property $cli_detection is not named in camelCase. This check marks property names that have not been written in camelCase. In camelCase names are written without any punctuation, the start of each new word being marked by a capital letter. Thus the name database connection string becomes `databaseConnectionString`. Loading history... Coding Style introduced 2018-04-22 14:37 UTC by Report Bug Copy Issue Report The property $plugin_pool is not named in camelCase. This check marks property names that have not been written in camelCase. In camelCase names are written without any punctuation, the start of each new word being marked by a capital letter. Thus the name database connection string becomes `databaseConnectionString`. Loading history...
13			{
14			/**
15			* @var mixed Kint mode
16			*
17			* false: Disabled
18			* true: Enabled, default mode selection
19			* other: Manual mode selection
20			*/
21			public static $enabled_mode = true;
			0 ignored issues – show Coding Style introduced 2018-01-09 18:27 UTC by Report Bug Copy Issue Report `$enabled_mode` does not seem to conform to the naming convention (`^[a-z][a-zA-Z0-9]*$`). This check examines a number of code elements and verifies that they conform to the given naming conventions. You can set conventions for local variables, abstract classes, utility classes, constant, properties, methods, parameters, interfaces, classes, exceptions and special methods. Loading history...
22
23			/**
24			* Default mode.
25			*
26			* @var string
27			*/
28			public static $mode_default = self::MODE_RICH;
			0 ignored issues – show Coding Style introduced 2018-01-09 18:27 UTC by Report Bug Copy Issue Report `$mode_default` does not seem to conform to the naming convention (`^[a-z][a-zA-Z0-9]*$`). This check examines a number of code elements and verifies that they conform to the given naming conventions. You can set conventions for local variables, abstract classes, utility classes, constant, properties, methods, parameters, interfaces, classes, exceptions and special methods. Loading history...
29
30			/**
31			* Default mode in CLI with cli_detection on.
32			*
33			* @var string
34			*/
35			public static $mode_default_cli = self::MODE_CLI;
			0 ignored issues – show Coding Style introduced 2018-01-09 18:27 UTC by Report Bug Copy Issue Report `$mode_default_cli` does not seem to conform to the naming convention (`^[a-z][a-zA-Z0-9]*$`). This check examines a number of code elements and verifies that they conform to the given naming conventions. You can set conventions for local variables, abstract classes, utility classes, constant, properties, methods, parameters, interfaces, classes, exceptions and special methods. Loading history...
36

jnvsor / kint

Push — test ( b3915a...cbea0e )

Kint::getSingleCall() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like