Kint\Kint

Complexity

Total Complexity

77

Size/Duplication

Total Lines	573
Duplicated Lines	3.84 %

Coupling/Cohesion

Components	3
Dependencies	5

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
B	settings()	0	33	4
B	trace()	0	25	4
A	dumpArray()	0	12	1
F	dump()	13	160	37
D	shortenPath()	0	37	10
A	getIdeLink()	0	4	1
F	getCalleeInfo()	9	97	20

<?php

namespace Kint;

use Kint\Object\BasicObject;
use Kint\Object\NothingObject;
use Kint\Parser\Parser;
use Kint\Parser\Plugin;
use Kint\Parser\TracePlugin;

class Kint

Kint does not seem to conform to the naming convention (Utils?$).

The property $enabled_mode is not named in camelCase.

The property $mode_default is not named in camelCase.

The property $mode_default_cli is not named in camelCase.

The property $file_link_format is not named in camelCase.

The property $display_called_from is not named in camelCase.

The property $app_root_dirs is not named in camelCase.

The property $max_depth is not named in camelCase.

The property $cli_detection is not named in camelCase.

The property $plugin_pool is not named in camelCase.

The property $dump_array is not named in camelCase.

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

$enabled_mode does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

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

$mode_default does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

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

$mode_default_cli does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

    /**
     * @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 = '';

$file_link_format does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

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

$display_called_from does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

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

$app_root_dirs does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

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

$max_depth does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

    /**
     * @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;

$cli_detection does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

    /**
     * @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',
    );

    private static $plugin_pool = array();

$plugin_pool does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

    private static $dump_array = false;

$dump_array does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

    private static $names = array();

    /**
     * Stashes or sets all settings at once.
     *
     * @param array|null $settings Array of all settings to be set or null to set none
     *
     * @return array Current settings
     */
    public static function settings(array $settings = null)
    {
        static $keys = array(
            'aliases',
            'app_root_dirs',
            'cli_detection',
            'display_called_from',
            'enabled_mode',
            'expanded',
            'file_link_format',
            'max_depth',
            'mode_default',
            'mode_default_cli',
            'renderers',
            'return',
            'plugins',
        );

        $out = array();

        foreach ($keys as $key) {
            $out[$key] = self::$$key;
        }

        if ($settings !== null) {
            $in = array_intersect_key($settings, $out);

Avoid variables with short names like $in. Configured minimum length is 3.

            foreach ($in as $key => $val) {
                self::$$key = $val;
            }
        }

        return $out;
    }

    /**
     * Prints a debug backtrace, same as Kint::dump(1).
     *
     * @param array $trace [OPTIONAL] you can pass your own trace, otherwise, `debug_backtrace` will be called

Should the type for parameter $trace not be null|array? Also, consider making the array more specific, something like array<String>, or String[].

     *
     * @return mixed

Consider making the return type a bit more specific; maybe use integer|string.

     */
    public static function trace(array $trace = null)
    {
        if ($trace === null) {
            $trace = debug_backtrace(true);

Consider using a different name than the parameter $trace. This often makes code more readable.

        } else {
            return self::dump($trace);
        }

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

        $trimmed_trace = array();

$trimmed_trace does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

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

$trimmed_trace does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            }

            $trimmed_trace[] = $frame;

$trimmed_trace does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        }

        return self::dumpArray(
            array($trimmed_trace),

$trimmed_trace does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

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

    /**
     * Dumps an array as separate values, and uses $names to seed the parser.
     *
     * @param array              $data  Data to be dumped
     * @param BasicObject[]|null $names Array of BasicObject to seed the parser with
     */
    public static function dumpArray(array $data, array $names = null)
    {
        self::$names = $names;

It seems like $names can be null. However, the property $names is declared as array. Maybe change the type of the property to array|null or add a type check?

        self::$dump_array = true;

        $out = self::dump($data);

        self::$names = null;

It seems like null of type null is incompatible with the declared type array of property $names.

        self::$dump_array = false;

        return $out;
    }

    /**
     * Dump information about variables, accepts any number of parameters, supports modifiers:.
     *
     *  clean up any output before kint and place the dump at the top of page:
     *   - Kint::dump()
     *  *****
     *  expand all nodes on display:
     *   ! Kint::dump()
     *  *****
     *  dump variables disregarding their depth:
     *   + Kint::dump()
     *  *****
     *  return output instead of displaying it:
     *
     *   @ Kint::dump()
     *  *****
     *  force output as plain text
     *   ~ Kint::dump()
     *
     * Modifiers are supported by all dump wrapper functions, including Kint::trace(). Space is optional.
     *
     * @param mixed $data
     *
     * @return int|string
     */
    public static function dump($data = null)
    {
        if (!self::$enabled_mode) {
            return 0;
        }

        $stash = self::settings();
        $num_args = func_num_args();

$num_args does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        list($params, $modifiers, $callee, $caller, $minitrace) = self::getCalleeInfo(
            debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS),
            $num_args

$num_args does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        );

        // set mode for current run
        if (self::$enabled_mode === true) {

This code seems to be duplicated across your project.

            self::$enabled_mode = self::$mode_default;
            if (PHP_SAPI === 'cli' && self::$cli_detection === true) {
                self::$enabled_mode = self::$mode_default_cli;
            }
        }

        if (in_array('~', $modifiers)) {
            self::$enabled_mode = self::MODE_TEXT;
        }

        if (!array_key_exists(self::$enabled_mode, self::$renderers)) {
            $renderer = self::$renderers[self::MODE_PLAIN];
        } else {
            $renderer = self::$renderers[self::$enabled_mode];
        }

        // process modifiers: @, +, ! and -
        if (in_array('-', $modifiers)) {
            while (ob_get_level()) {
                ob_end_clean();
            }
        }
        if (in_array('!', $modifiers)) {
            self::$expanded = true;
        }
        if (in_array('+', $modifiers)) {
            self::$max_depth = 0;
        }
        if (in_array('@', $modifiers)) {
            self::$return = true;
        }

        $renderer = new $renderer(array(
            'num_args' => $num_args,

$num_args does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            'params' => $params,
            'modifiers' => $modifiers,
            'callee' => $callee,
            'caller' => $caller,
            'minitrace' => $minitrace,
            'settings' => self::settings(),
            'stash' => $stash,
        ));

        $plugins = array();

        foreach (self::$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 = $renderer->parserPlugins($plugins);

        $output = $renderer->preRender();

        $parser = new Parser(self::$max_depth, empty($caller['class']) ? null : $caller['class']);

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

        // Kint::dump(1) shorthand
        if (!self::$dump_array && (!isset($params[0]['name']) || $params[0]['name'] == '1') && $num_args === 1 && $data === 1) {

$num_args does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            $data = debug_backtrace(true);

Consider using a different name than the parameter $data. This often makes code more readable.

            $trace = array();

            // No need to normalize as we've already called it through getCalleeInfo at this point
            foreach ($data as $index => $frame) {

This code seems to be duplicated across your project.

                if (TracePlugin::frameIsListed($frame, self::$aliases)) {
                    $trace = array();
                }

                $trace[] = $frame;
            }

            $lastframe = reset($trace);
            $tracename = $lastframe['function'].'(1)';
            if (isset($lastframe['class'], $lastframe['type'])) {
                $tracename = $lastframe['class'].$lastframe['type'].$tracename;
            }
            $tracebase = BasicObject::blank($tracename, 'debug_backtrace()');

            $output .= $renderer->render($parser->parse($trace, $tracebase));
        } else {
            $data = func_get_args();

Consider using a different name than the parameter $data. This often makes code more readable.

            if ($data === array()) {
                $output .= $renderer->render(new NothingObject());
            }

            if (self::$dump_array) {
                $data = $data[0];

Consider using a different name than the parameter $data. This often makes code more readable.

            }

            static $blacklist = array('null', 'true', 'false', 'array(...)', 'array()', '"..."', 'b"..."', '[...]', '[]', '(...)', '()');

            foreach ($data as $i => $argument) {
                if (isset(self::$names[$i])) {
                    $output .= $renderer->render(
                        $parser->parse($argument, self::$names[$i])
                    );
                    continue;
                }

                if (!isset($params[$i]['name']) || is_numeric($params[$i]['name']) || in_array(str_replace("'", '"', strtolower($params[$i]['name'])), $blacklist, true)) {
                    $name = null;
                } else {
                    $name = $params[$i]['name'];
                }

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

$access_path does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

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

$access_path does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

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

$access_path does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                }

                $output .= $renderer->render(
                    $parser->parse($argument, BasicObject::blank($name, $access_path))

$access_path does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                );
            }
        }

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

        if (self::$return) {
            self::settings($stash);

            return $output;
        }

        self::settings($stash);
        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'));

Consider using a different name than the parameter $file. This often makes code more readable.

        $longest_match = 0;

$longest_match does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        $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 does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                $longest_match = count($path);

$longest_match does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                $match = $alias;
            }
        }

        if ($longest_match) {

$longest_match does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

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

$longest_match does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

Consider using a different name than the parameter $file. This often makes code more readable.

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

    /**
     * returns parameter names that the function was passed, as well as any predefined symbols before function
     * call (modifiers).
     *
     * @param array $trace
     *
     * @return array($params, $modifiers, $callee, $caller, $miniTrace)

The doc-type array($params, could not be parsed: Expected "|" or "end of type", but got "(" at position 5. (view supported doc-types)

     */
    private static function getCalleeInfo($trace, $num_params)

$num_params does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

The parameter $num_params is not named in camelCase.

    {
        TracePlugin::normalizeAliases(self::$aliases);
        $miniTrace = array();

        foreach ($trace as $index => $frame) {

This code seems to be duplicated across your project.

            if (TracePlugin::frameIsListed($frame, self::$aliases)) {
                $miniTrace = array();
            }

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

        $callee = reset($miniTrace);
        $caller = next($miniTrace);
        if (!$callee) {
            $callee = null;
        }
        if (!$caller) {
            $caller = null;
        }

        unset($miniTrace[0]);

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

        $miniTrace = array_values($miniTrace);

        if (!isset($callee['file'], $callee['line']) || !is_readable($callee['file'])) {
            return array(null, array(), $callee, $caller, $miniTrace);
        }

        // open the file and read it up to the position where the function call expression ended
        if (empty($callee['class'])) {
            $callfunc = $callee['function'];
        } else {
            $callfunc = array($callee['class'], $callee['function']);
        }

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

        $return = array(null, array(), $callee, $caller, $miniTrace);

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

$is_unpack does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            // 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 < $num_params; ++$j) {

$num_params does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

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

$is_unpack does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                        break;
                    }
                }
            }

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

$is_unpack does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                if ($return[0] === null) {
                    $return = array($call['parameters'], $call['modifiers'], $callee, $caller, $miniTrace);
                } 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 array(null, array(), $callee, $caller, $miniTrace);
                }
            }
        }

        return $return;
    }
}