Kint\Kint

Complexity

Total Complexity

102

Size/Duplication

Total Lines	713
Duplicated Lines	1.96 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	setParser()	0	4	1
A	getParser()	0	4	1
A	setRenderer()	0	4	1
A	getRenderer()	0	4	1
D	setStatesFromStatics()	0	33	9
B	setStatesFromCallInfo()	0	20	7
B	dumpAll()	0	23	5
A	dumpVar()	0	6	1
A	getStatics()	0	18	1
D	createFromStatics()	0	31	9
C	getBasesFromParamInfo()	0	51	8
F	getCallInfo()	0	119	21
C	trace()	7	56	10
C	dump()	7	68	15
D	shortenPath()	0	37	10
A	getIdeLink()	0	4	1

<?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

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.

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

    protected static $plugin_pool = array();

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

    protected $parser;
    protected $renderer;

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

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

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

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

    public function setParser(Parser $p)

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

    {
        $this->parser = $p;
    }

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

    public function setRenderer(Renderer $r)

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

    {
        $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);
        $kintstance->setStatesFromStatics($statics);

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

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

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

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

                if (!empty($param['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]*$).

            }

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

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

        }

        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

The doc-type array[5] could not be parsed: Expected "]" at position 2, but found "5". (view supported doc-types)

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

        if (!isset($callee['file'], $callee['line']) || !is_readable($callee['file'])) {
            return array(
                'params' => null,
                'modifiers' => array(),
                'callee' => $callee,
                'caller' => $caller,
                'trace' => $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(
            'params' => null,
            'modifiers' => array(),
            'callee' => $callee,
            'caller' => $caller,
            'trace' => $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 < $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;

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

                        break;
                    }
                }
            }

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

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

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

        return $return;
    }

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

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

        $args = func_get_args();

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

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

        $statics = self::getStatics();

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

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

            $statics['enabled_mode'] = self::MODE_TEXT;
        }

        $kintstance = self::createFromStatics($statics);

        if (!$kintstance) {
            return 0;
        }

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

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

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

        $kintstance->setStatesFromCallInfo($call_info);

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

        $trimmed_trace = array();

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

        $trace = debug_backtrace(true);

        foreach ($trace as $frame) {
            if (Utils::traceFrameIsListed($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]*$).

        }

        $output = $kintstance->dumpAll(
            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(true)'))
        );

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

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

This code seems to be duplicated across your project.

            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()
    {
        if (!self::$enabled_mode) {
            return 0;
        }

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

        $args = func_get_args();

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

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

        $statics = self::getStatics();

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

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

            $statics['enabled_mode'] = self::MODE_TEXT;
        }

        $kintstance = self::createFromStatics($statics);

        if (!$kintstance) {
            return 0;
        }

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

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

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

        $kintstance->setStatesFromCallInfo($call_info);

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

        // 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')) {

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

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

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

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

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

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

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

            }
            $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(),

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

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

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

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

This code seems to be duplicated across your project.

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

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