1
0
Fork 0
MySQLDumper/library/Debug.php

501 Zeilen
14 KiB
PHP

2011-06-10 21:55:32 +00:00
<?php
/**
* Statische Klasse für Debug-Ausgaben.
*
* Die Klassenkonstanten sind global mit dem Präfix <i>DEBUG_</i> verfügbar.
*
* @package MySQLDumper
* @author D4rk4ng3l
* @version 0.3
* @copyright 2010 Stefan 'D4rk4ng3l' Krenz
*/
/**
* Debug class by Stefan Krenz
*
* @package MySQLDumper
*
*/
class Debug
{
/**
* Debug-Ausgabe als einfacher Text.
*/
const OUTPUT_PLAIN = 0x000001;
/**
* Debug-Ausgabe als HTML-Quelltext.
*/
const OUTPUT_HTML = 0x000002;
/**
* Debug-Ausgabe als HTML-Kommentar.
*/
const OUTPUT_HTML_COMMENT = 0x000003;
/**
* Debug-Ausgabe in einer Datei als einfacher Text.
* {@link Debug::setOutputFilename()}
*/
const OUTPUT_FILE = 0x000004;
/**
* Debug-Ausgabe als Javascript Kommentar.
*/
const OUTPUT_JAVASCRIPT = 0x000005;
/**
* Alias für {@link Debug::OUTPUT_JAVASCRIPT}
*/
const OUTPUT_JS = 0x000005;
/**
* Backtrace-Ausgabe deaktivieren.
*/
const BACKTRACE_NONE = 0x000100;
/**
* Einfache Backtrace-Ausgabe. Gibt nur die <i>Debug::out()</i>
* aufrufende Funktion aus.
*/
const BACKTRACE_SIMPLE = 0x000200;
/**
* Komplexe Backtrace-Ausgabe. Gibt alle aufrufenden Funktionen aus.
*/
const BACKTRACE_COMPLETE = 0x000300;
/**
* HTML-Quelltext im HTML-Format ausgeben.
*/
const HTMLMODE_HTML = 0x010000;
/**
* HTML-Quelltext im XHTML-Format ausgeben.
*/
const HTMLMODE_XHTML = 0x020000;
/**
* Speichert den Modus für die Debug-Ausgabe.
*
* Siehe auch:
* {@link Debug::OUTPUT_PLAIN}
* {@link Debug::OUTPUT_HTML}
* {@link Debug::OUTPUT_HTML_COMMENT}
* {@link Debug::OUTPUT_FILE}
*
* @var int Ausgabemodus
* @static
*/
private static $_outputMode = self::OUTPUT_HTML;
/**
* Speichert den Modus für die Backtrace-Ausgabe.
*
* Siehe auch:
* {@link Debug::BACKTRACE_NONE}
* {@link Debug::BACKTRACE_SIMPLE}
* {@link Debug::BACKTRACE_COMPLETE}
*
* @var int Backtracemodus
* @static
*/
private static $_backtraceMode = self::BACKTRACE_SIMPLE;
/**
* Speichert den Modus für die HTML-Ausgabe.
*
* Siehe auch: {@link Debug::HTMLMODE_HTML, Debug::HTMLMODE_XHTML}
*
* @var int HTML-Quelltext-Modus
* @static
*/
private static $_htmlMode = self::HTMLMODE_HTML;
/**
* Speichert Informationen über die registrierten Callback-Funktionen.
*
* Nähere Informationen zum <i>callback</i> Typ:
* siehe PHP-Manual
*
* @var array Benutzerdefinierte Callback-Funktionen
* @static
*/
private static $_callbacks = array(
self::OUTPUT_PLAIN => array(__CLASS__, 'defaultCallback'),
self::OUTPUT_HTML => array(__CLASS__, 'defaultCallback'),
self::OUTPUT_HTML_COMMENT => array(__CLASS__, 'defaultCallback'),
self::OUTPUT_FILE => array(__CLASS__, 'defaultCallback'),
self::OUTPUT_JAVASCRIPT => array(__CLASS__, 'defaultCallback'),
);
/**
* Speichert den Inhalt der zuletzt ausgegebenen Variablen.
*
* @var mixed Letzte ausgegebene Variable.
* @static
*/
private static $_lastVariable = null;
/**
* Speichert den Backtrace der letzten Debug-Ausgabe.
*
* @var array Backtrace der letzten Debug-Ausgabe
* @static
*/
private static $_lastBacktrace = null;
/**
* Speichert den HTML-Quellcode für den Zeilenumbruch,
* basierend auf dem aktuellen HTML-Ausgabe-Modus.
*
* @var string Zeilenumbruch für HTML-Ausgabe
*/
private static $_htmlLineBreak = "<br>\n";
/**
* Speichert den Dateinamen für die Dateiausgabe.
*
* Siehe auch: {@link Debug::OUTPUT_FILE}
*
* @var string Dateiname für die Debug-Ausgabe
*/
private static $_outputFilename = 'debug.txt';
/**
* Deaktivierter Konstruktor. Klasse ist nur statisch zu benutzen.
*/
private function __construct()
{
}
/**
* Deaktiviertes klonen.
*/
private function __clone()
{
}
/**
* Gibt eine typbasierte Ausgabe zurück.
*
* Ist $arg ein Array, so wird 'Array' zurückgeben.
* Ist $arg ein Objekt, so wird der Name der Klasse zurückgeben.
* Ist $arg ein Boolean, so wird 'TRUE' bzw. 'FALSE' zurückgeben.
* Ist $arg ein String, so wird er in Anführungsstriche gesetzt.
* Ist $arg null, so wird 'NULL' zurückgeben.
* Ist der Typ der Variablen $arg unbekannt,
* so wird die Variable selbst zurückgegeben.
*
* @param mixed $arg Funktionparameter
*
* @return mixed
*/
private static function getArg($arg)
{
if (is_array($arg)) {
$result = 'Array';
} elseif (is_object($arg)) {
$result = get_class($arg);
} elseif (is_bool($arg)) {
$result = $arg ? 'TRUE' : 'FALSE';
} elseif (is_string($arg)) {
$result = '"' . $arg . '"';
} elseif (is_null($arg)) {
$result = 'NULL';
} else {
$result = $arg;
}
return $result;
}
private static function _getBacktrace($backtrace, $outputBacktraceType)
{
$outputBacktrace = '';
switch ($outputBacktraceType) {
case self::BACKTRACE_NONE:
break;
case self::BACKTRACE_SIMPLE:
$outputBacktrace = 'Debugoutput called from '
. $backtrace[0]['file'] . '['
. $backtrace[0]['line'] . ']';
break;
case self::BACKTRACE_COMPLETE:
foreach ($backtrace as $traceNum => $trace) {
$args = (count($trace['args']) > 0) ?
self::getArg($trace['args'][0]) : '';
for ($i = 1; $i < count($trace['args']); $i++) {
$args .= ', ' . self::getArg($trace['args'][$i]);
}
$outputBacktrace .= '#' . $traceNum . ': ' . $trace['file']
. '[' . $trace['line'] . '] ' . $trace['class']
. $trace['type'] . $trace['function'] . '('
. $args . ")\n";
}
break;
default:
$outputBacktrace = 'Debugoutput called from '
. $backtrace[0]['file'] . '[' . $backtrace[0]['line'] . ']';
break;
}
return $outputBacktrace;
}
private static function _doOutput(
$outputFormatType,
$outputBacktrace,
$dumpedVar,
$outputHtmlModeType
)
{
switch ($outputFormatType) {
case self::OUTPUT_PLAIN:
echo $outputBacktrace;
echo $dumpedVar;
break;
case self::OUTPUT_HTML:
echo '<strong>' .
nl2br(
$outputBacktrace,
($outputHtmlModeType == self::HTMLMODE_XHTML)
) . '</strong>' . self::$_htmlLineBreak;
echo '<pre>';
echo htmlspecialchars($dumpedVar);
echo '</pre>';
break;
case self::OUTPUT_HTML_COMMENT:
echo '<!--' . "\n" . $outputBacktrace . "\n\n";
echo $dumpedVar;
echo "\n" . '-->'. "\n";
break;
case self::OUTPUT_FILE:
$output = $outputBacktrace . "\n";
$output .= $dumpedVar . "\n\n";
$filePointer = fopen(self::$_outputFilename, "a+");
fwrite($filePointer, $output);
fclose($filePointer);
break;
case self::OUTPUT_JAVASCRIPT:
echo "/*\n";
echo $outputBacktrace . "\n\n";
echo $dumpedVar;
echo "\n*/\n";
}
}
/**
* Standard Callback-Funktion
*
* Siehe auch: {@link Debug::$_callbacks}
*
* @param mixed $var Variable, die ausgegeben werden soll.
* @param array $backtrace Backtrace des Aufrufs von <i>Debug::out()</i>
* @param int $outputFormat Ausgabe-Format
*
* @return void
*/
public static function defaultCallback($var, $backtrace, $outputFormat)
{
$outputFormatType = ($outputFormat | 0xFFFFFF00) ^ 0xFFFFFF00;
$outputBacktraceType = ($outputFormat | 0xFFFF00FF) ^ 0xFFFF00FF;
$outputHtmlModeType = ($outputFormat | 0xFF00FFFF) ^ 0xFF00FFFF;
if ($outputFormatType == 0) {
$outputFormatType = self::$_outputMode;
}
if ($outputBacktraceType == 0) {
$outputBacktraceType = self::$_backtraceMode;
}
if ($outputHtmlModeType == 0) {
$outputHtmlModeType = self::$_htmlMode;
}
self::$_htmlLineBreak = nl2br(
"\n",
($outputHtmlModeType == self::HTMLMODE_XHTML)
);
ob_start();
var_dump($var);
$dumpedVar = ob_get_contents();
ob_end_clean();
$outputBacktrace = self::_getBacktrace(
$backtrace,
$outputBacktraceType
);
self::_doOutput(
$outputFormatType,
$outputBacktrace,
$dumpedVar,
$outputHtmlModeType
);
}
/**
* Erzeugt eine Ausgabe, die beim Auffinden
* von Fehlern (debugging) unterstützt.
*
* @param mixed $var Variable, die ausgegeben werden soll.
* @param int $outputFormat Format für die Ausgabe.
*
* @return void
*/
public static function out($var, $outputFormat = null)
{
if ($outputFormat === null) {
$outputFormat = self::$_outputMode |
self::$_backtraceMode |
self::$_htmlMode;
}
$outputFormatType = ($outputFormat | 0xFFFFFF00) ^ 0xFFFFFF00;
if ($outputFormatType == 0) {
$outputFormatType = self::$_outputMode;
$outputFormat = self::$_outputMode | $outputFormat;
}
$backtrace = debug_backtrace();
if (isset(self::$_callbacks[$outputFormatType])) {
call_user_func_array(
self::$_callbacks[$outputFormatType],
array($var, $backtrace, $outputFormat)
);
} else {
$message = 'Für das angegebene Ausgabeformat wurde keine '
. 'Callback-Funktion definiert. Format: 0x'
. sprintf('%8.8X', $outputFormatType);
throw new Exception($message);
}
self::$_lastBacktrace = $backtrace;
self::$_lastVariable = $var;
}
/**
* Gibt den Backtrace des letzten Aufrufs von <i>Debug::out()</i> zurück.
*
* @return array
*/
public static function getLastBacktrace()
{
return self::$_lastBacktrace;
}
/**
* Gibt den Inhalt der zuletzt ausgegebenen Variablen zurück.
*
* @return mixed
*/
public static function getLastVariable()
{
return self::$_lastVariable;
}
/**
* Fügt eine Callback-Funktion zum Stack hinzu,
* diese wird beim Aufruf von <i>Debug::out()</i>
* automatisch aufgerufen. Diese Funktion muss gleichzeitig den Inhalt
* des <i>Debug::out()</i> Aufrufs ausgeben.
*
* Für nähere Informationen über mögliche
* Callback-Funktionen {@link Debug::$_callbacks}
*
* Die Callback-Funktion muss dem folgenden Format entsprechen:
* method null callback($var, $backtrace, $outputFormat)
* {@link Debug::defaultCallback()}
*
* Benutze für das Ausgabeformat ($outputFormat)
* einen Integer zwischen 0x10 und 0xFF.
*
* Alternativ kann für $outputFormat auch ein Array übergeben werden.
* Es gilt dann die Konvention:
* Index 0: Ausgabeformat (entspricht $outputFormat mit einem Integer)
* Index 1: Callback-Information (entspricht $callbackFunction)
*
* Ausgabeformate sollten global mit dem Präfix
* 'DEBUG_OUTPUT_' registriert werden.
* Zusätzliche Ausgabeinformationen können in den
* Bytes 3 und 4 (0xFFFF0000) übergeben werden.
*
* @param mixed $outputFormat Ausgabeformat
* @param mixed $callbackFunction Informationen über die Callback-Funktion
*
* @return bool
*/
public static function registerCallbackFunction(
$outputFormat,
$callbackFunction = null
)
{
if (is_array($outputFormat)) {
self::$_callbacks[$outputFormat[0]] = $outputFormat[1];
return is_callable($outputFormat[1]);
} else {
self::$_callbacks[$outputFormat] = $callbackFunction;
return is_callable($callbackFunction);
}
}
/**
* Entfernt eine Callback-Funktion vom Stack.
*
* @param int $outputFormat Ausgabeformat
*/
public static function unregisterCallbackFunction($outputFormat)
{
unset(self::$_callbacks[$outputFormat]);
}
/**
* Setzt den Modus für die Ausgabe.
* {@link Debug::$_outputMode}
*
* @param int $outputMode Ausgabemodus
*/
public static function setDefaultOutputMode($outputMode)
{
self::$_outputMode = $outputMode;
}
/**
* Setzt den Modus für den Backtrace.
* {@link Debug::$_backtraceMode}
*
* @param int $backtraceMode Backtrace-Modus
*/
public static function setDefaultBacktraceMode($backtraceMode)
{
self::$_backtraceMode = $backtraceMode;
}
/**
* Setzt den Modus für die HTML-Ausgabe
* {@link Debug::$_htmlMode}
*
* @param int $htmlMode HTML-Modus
*/
public static function setDefaultHtmlMode($htmlMode)
{
self::$_htmlMode = $htmlMode;
}
/**
* Setzt den Dateinamen für die Dateiausgabe.
* {@link Debug::$_outputFilename}
*
* @param string $outputFilename Dateiname
*/
public static function setOutputFilename($outputFilename = 'debug.txt')
{
self::$_outputFilename = $outputFilename;
}
}
$debugReflection = new ReflectionClass('Debug');
$constants = $debugReflection->getConstants();
foreach ($constants as $constantName => $constantValue) {
define('DEBUG_' . $constantName, $constantValue);
}