Koch\Debug\Debug

Complexity

Total Complexity

51

Size/Duplication

Total Lines	328
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	1
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
B	getOriginOfDebugCall()	0	32	3
B	getIncludedFiles()	0	33	6
A	getApplicationConstants()	0	7	2
A	getBacktrace()	0	6	2
A	getInterfaces()	0	6	2
A	getClasses()	0	6	2
A	getFunctions()	0	6	2
A	getExtensions()	0	6	2
A	getPhpIni()	0	6	2
B	getWrappers()	0	13	5
B	dump()	0	31	5
A	firebug()	0	18	1
D	printR()	0	67	17

<?php

/**
 * Koch Framework
 * Jens-André Koch © 2005 - onwards.
 *
 * This file is part of "Koch Framework".
 *
 * License: GNU/GPL v2 or any later version, see LICENSE file.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

namespace Koch\Debug;

/**
 * Debug.
 *
 * This class initializes debugging helpers like xdebug, the doctrine profiler,
 * firebug and printR at system start-up and displays debug
 * and runtime-informations on demand or at application shutdown.
 */
class Debug

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

{
    /**
     * This is an enhanced version of the native php function print_r().
     *
     * @param mixed/array/object $var Array or Object as Variable to display

The doc-type mixed/array/object could not be parsed: Unknown type name "mixed/array/object" at position 0. (view supported doc-types)

     * @returns Returns a better structured display of an array/object as native print_r().
     */
    public static function printR($var)
    {
        // this will handle more than one parameter
        if (func_num_args() > 1) {
            $vars = func_get_args();
        }

        $backtrace_array = [];

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

$backtrace_array is not used, you could remove the assignment.

        $backtrace_array = debug_backtrace();

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

        $trace           = array_shift($backtrace_array);

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

        $file            = file($trace['file']);
        $trace_line      = $file[$trace['line'] - 1];

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

        echo '<pre>';
        echo '<b>Debugging ';
        echo '<font color=red>' . basename($trace['file']) . '</font>';
        echo ' on line <font color=red>' . $trace['line'] . '</font></b>:' . "\n";
        echo "<div style='background: #f5f5f5; padding: 0.2em 0em;'>" . htmlspecialchars($trace_line) . '</div>' . "\n";

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

        echo '<b>Type</b>: ' . gettype($var) . "\n"; // uhhh.. gettype is slow like hell

        // handle more than one parameter
        foreach ($vars as $var) {

The variable $vars does not seem to be defined for all execution paths leading up to this point.

            if (is_string($var)) {
                echo '<b>Length</b>: ' . strlen($var) . "\n";
            }

            if (is_array($var)) {
                echo '<b>Length</b>: ' . count($var) . "\n";
            }

            echo '<b>Value</b>: ';

            if ($var === true) {
                echo '<font color=green><b>true</b></font>';
            } elseif ($var === false) {
                echo '<font color=red><b>false</b></font>';
            } elseif ($var === null) {
                echo '<font color=red><b>null</b></font>';
            } elseif ($var === 0) {
                echo '0';
            } elseif (is_string($var) and strlen($var) === '0') {

Using logical operators such as and instead of && is generally not recommended.

The strict comparison === seems to always evaluate to false as the types of strlen($var) (integer) and '0' (string) can never be identical. Maybe you want to use a loose comparison == instead?

                echo '<font color=green>*EMPTY STRING*</font>';
            } elseif (is_string($var)) {
                echo htmlspecialchars($var);
            } else {
                $print_r = print_r($var, true);

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

                // str_contains < or >
                if ((strstr($print_r, '<') !== false) || (strstr($print_r, '>') !== false)) {

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

                    $print_r = htmlspecialchars($print_r);

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

                }
                echo $print_r;

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

            }
        }

        echo '</pre>';

        // save session before exit
        if ((bool) session_id()) {
            session_write_close();
        }

        // do not exit, if we are inside a test run
        if (defined('UNIT_TEST_RUN') === false or UNIT_TEST_RUN === false) {

Using logical operators such as or instead of || is generally not recommended.

            \Koch\Tools\ApplicationQuit::quit();
        }
    }

    /**
     * Displays the content of a variable with var_dump.
     * The content gets escaping and pre tags are applied for better readability.
     *
     * @param mixed $var  The variable to debug.
     * @param bool  $exit Stop execution after dump? Default is true (stops).
     */
    public static function dump($var, $exit = true)
    {
        // var_dump the content into a buffer and store it to variable
        ob_start();
        var_dump($var);

var_dump($var); looks like debug code. Are you sure you do not want to remove it? This might expose sensitive data.

        $var_dump = ob_get_clean();

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

        /*
         * if xdebug is on and overloaded the var_dump function,
         * then the output is already properly escaped and prepared for direct output.
         * if xdebug is off, we need to apply escaping ourself.
         * html pre tags are applied to structure the display a bit more.
         */
        if (false === extension_loaded('xdebug')) {
            $var_dump = preg_replace('/\]\=\>\n(\s+)/m', '] => ', $var_dump);

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

            $var_dump = '<pre>' . htmlspecialchars($var_dump, ENT_QUOTES, 'UTF-8') . '</pre>';

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

        }

        // display where this debug statement
        echo self::getOriginOfDebugCall();

        // output the content of the buffer
        echo $var_dump;

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

        // do not exit, if we are inside a test run
        if (defined('UNIT_TEST_RUN') === false or UNIT_TEST_RUN === false) {

Using logical operators such as or instead of || is generally not recommended.

            if ($exit === true) {
                \Koch\Tools\ApplicationQuit::quit();
            }
        }
    }

    /**
     * Debug logs the output of $var to the firebug console in your browser.
     *
     * @param mixed $var The variable to debug.
     * @param $logmethod The firebug method to call for logging (log,info,warn, error). Defaults to "log".
     *
     * @return FirePHP object.

Should the return type not be FirePHP|null?

     */
    public static function firebug($var, $logmethod = 'log')
    {
        // @codeCoverageIgnoreStart
        // We don't need to test vendor library functionality.
        // @see FirePHPCore_FirePHPTest

        $firephp = \FirePHP::getInstance(true);

        /*
         * Adds an info message about the position of the firebug call (origin).
         * This is very helpful if you spread Debug::firebug() calls all over your code.
         */
        $firephp->info(self::getOriginOfDebugCall());

self::getOriginOfDebugCall() is of type string|null, but the function expects a object<mixes>.

        $firephp->{$logmethod}($var);

        // @codeCoverageIgnoreEnd
    }

    /**
     * Returns the position of a call.
     *
     * This is used to determine the origin of the debug call.
     * Its mostly used in combination with several debug calls,
     * like \Koch\Debug\Debug::firebug() or \Koch\Debug\Debug::printR()
     * which are enhanced debug displays.
     *
     * It is a very helpful reminder to find and remove debug calls,
     * which you spread all over your code while tracking down a bug,
     * but forgot the trace path or where exactly they are.
     *
     * If you have a multitude of debug calls, debug breadcrumbs or toc
     * would be good ;) But that's another story...
     *
     * The default level is 2 (0,1,2), because we have to skip
     * the 3 calls to dump() and getWhereDebugWasCalled().
     *
     * @param int $level Default 1.
     *
     * @return string Message with origin of the debug call.

Should the return type not be string|null?

     */
    public static function getOriginOfDebugCall($level = 1)

getOriginOfDebugCall uses the super-global variable $_SERVER which is generally not recommended.

    {
        $trace = [];

$trace is not used, you could remove the assignment.

        $file  = $line  = $function  = $class  = $object  = $trace_line  = '';

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

$trace_line is not used, you could remove the assignment.

$object is not used, you could remove the assignment.

$class is not used, you could remove the assignment.

$function is not used, you could remove the assignment.

$line is not used, you could remove the assignment.

$file is not used, you could remove the assignment.

        // Get the backtrace and the caller information.
        $trace = debug_backtrace();
        $file  = $trace[$level]['file'];
        $line  = $trace[$level]['line'];
        #$function = $trace[$level]['function'];

75% of this comment could be valid code. Did you maybe forget this after debugging?

        #$class = $trace[$level]['class'];

75% of this comment could be valid code. Did you maybe forget this after debugging?

        /*
         * Get the file, to show the exact origin of the debug call.
         * The line with the call, is one line above.
         */
        $file_content   = file($file);

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

        $origin_of_call = trim($file_content[ $trace[$level]['line'] - 1 ]);

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

        // do not use HTML tags on CLI
        if (PHP_SAPI === 'cli') {
            if (empty($_SERVER['REMOTE_ADDR'])) {
                $format = 'Debugging %s on line %s: %s' . "\n";
            } else {
                $format = '<pre>';
                $format .= '<b>Debugging <font color="red">%s</font> on line <font color="red">%s</font>:</b>' . "\n";
                $format .= '<div style="background: #f5f5f5; padding: 0.2em 0em;">%s</div></pre>';
            }
        }

        echo sprintf($format, basename($file), $line, htmlspecialchars($origin_of_call));

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

The variable $format does not seem to be defined for all execution paths leading up to this point.

    }

    /**
     * The method
     * - lists all currently included and required files
     * - counts all includes files
     * - calculates the total size (combined filesize) of all inclusions.
     */
    public static function getIncludedFiles($returnArray = false)
    {
        // init vars
        $includedFiles = $files = $result = [];

$result is not used, you could remove the assignment.

$files is not used, you could remove the assignment.

        $totalSize     = 0;

        // fetch all included files
        $files = get_included_files();

        // loop over all included files and sum up filesize
        foreach ($files as $file) {

            // if system under test, skip virtual file system files,
            // as they might be already deleted by tearDown() methods.
            if (defined('UNIT_TEST_RUN') or UNIT_TEST_RUN) {

Using logical operators such as or instead of || is generally not recommended.

                if (stripos($file, 'vfs:/') !== false) {
                    continue;
                }
            }

            $size            = filesize($file);
            $includedFiles[] = ['name' => $file, 'size' => $size];
            $totalSize += $size;
        }

        $result = [
            'count' => count($files),
            'size'  => \Koch\Functions\Functions::getSize($totalSize),
            'files' => $includedFiles,
        ];

        return ($returnArray === true) ? $result : self::printR($result);
    }

    /**
     * Lists all user defined constants (Application Constants).
     */
    public static function getApplicationConstants($returnArray = false)

The return type could not be reliably inferred; please add a @return annotation.

    {
        $constants = get_defined_constants(true);
        $result    = $constants['user'];

        return ($returnArray === true) ? $result : self::printR($result);
    }

    /**
     * Displayes the debug backtrace.
     *
     * @param int Limit the number of stack frames returned. Returns all stack frames by default (limit=0).
     * @param bool
     */
    public static function getBacktrace($limit = 0, $returnArray = false)
    {
        $result = debug_backtrace($limit);

        return ($returnArray === true) ? $result : self::printR($result);
    }

    /**
     * Returns an array with the name of the defined interfaces.
     */
    public static function getInterfaces($returnArray = false)
    {
        $result = get_declared_interfaces();

        return ($returnArray === true) ? $result : self::printR($result);
    }

    /**
     * Returns an array with the name of the defined classes.
     */
    public static function getClasses($returnArray = false)
    {
        $result = get_declared_classes();

        return ($returnArray === true) ? $result : self::printR($result);
    }

    /**
     * Returns an array with the name of the defined classes.
     */
    public static function getFunctions($returnArray = false)
    {
        $result = get_defined_functions();

        return ($returnArray === true) ? $result : self::printR($result);
    }

    /**
     * Lists all php extensions.
     */
    public static function getExtensions($returnArray = false)
    {
        $result = get_loaded_extensions();

        return ($returnArray === true) ? $result : self::printR($result);
    }

    /**
     * Lists all php.ini settings.
     */
    public static function getPhpIni($returnArray = false)
    {
        $result = parse_ini_file(get_cfg_var('cfg_file_path'), true);

        return ($returnArray === true) ? $result : self::printR($result);
    }

    /**
     * Lists all available wrappers.
     */
    public static function getWrappers($returnArray = false)
    {
        $result = [];

        $wrappers = stream_get_wrappers();

        $result['openssl'] = (extension_loaded('openssl')) ? 'yes' : 'no';
        $result['http']    = in_array('http', $wrappers, true) ? 'yes' : 'no';
        $result['https']   = in_array('https', $wrappers, true) ? 'yes' : 'no';
        $result['all']     = $wrappers;

        return ($returnArray === true) ? $result : self::printR($result);
    }
}