+
+
+
+
+
+
+
diff --git a/library/Whoops/Run.php b/library/Whoops/Run.php
new file mode 100644
index 0000000..6f9ada0
--- /dev/null
+++ b/library/Whoops/Run.php
@@ -0,0 +1,390 @@
+
+ */
+
+namespace Whoops;
+
+use Exception;
+use InvalidArgumentException;
+use Whoops\Exception\ErrorException;
+use Whoops\Exception\Inspector;
+use Whoops\Handler\CallbackHandler;
+use Whoops\Handler\Handler;
+use Whoops\Handler\HandlerInterface;
+
+class Run
+{
+ const EXCEPTION_HANDLER = "handleException";
+ const ERROR_HANDLER = "handleError";
+ const SHUTDOWN_HANDLER = "handleShutdown";
+
+ protected $isRegistered;
+ protected $allowQuit = true;
+ protected $sendOutput = true;
+ protected $sendHttpCode = 500;
+
+ /**
+ * @var HandlerInterface[]
+ */
+ protected $handlerStack = array();
+
+ protected $silencedPatterns = array();
+
+ /**
+ * Pushes a handler to the end of the stack
+ *
+ * @throws InvalidArgumentException If argument is not callable or instance of HandlerInterface
+ * @param Callable|HandlerInterface $handler
+ * @return Run
+ */
+ public function pushHandler($handler)
+ {
+ if (is_callable($handler)) {
+ $handler = new CallbackHandler($handler);
+ }
+
+ if (!$handler instanceof HandlerInterface) {
+ throw new InvalidArgumentException(
+ "Argument to " . __METHOD__ . " must be a callable, or instance of"
+ . "Whoops\\Handler\\HandlerInterface"
+ );
+ }
+
+ $this->handlerStack[] = $handler;
+ return $this;
+ }
+
+ /**
+ * Removes the last handler in the stack and returns it.
+ * Returns null if there"s nothing else to pop.
+ * @return null|HandlerInterface
+ */
+ public function popHandler()
+ {
+ return array_pop($this->handlerStack);
+ }
+
+ /**
+ * Returns an array with all handlers, in the
+ * order they were added to the stack.
+ * @return array
+ */
+ public function getHandlers()
+ {
+ return $this->handlerStack;
+ }
+
+ /**
+ * Clears all handlers in the handlerStack, including
+ * the default PrettyPage handler.
+ * @return Run
+ */
+ public function clearHandlers()
+ {
+ $this->handlerStack = array();
+ return $this;
+ }
+
+ /**
+ * @param Exception $exception
+ * @return Inspector
+ */
+ protected function getInspector(Exception $exception)
+ {
+ return new Inspector($exception);
+ }
+
+ /**
+ * Registers this instance as an error handler.
+ * @return Run
+ */
+ public function register()
+ {
+ if (!$this->isRegistered) {
+ // Workaround PHP bug 42098
+ // https://bugs.php.net/bug.php?id=42098
+ class_exists("\\Whoops\\Exception\\ErrorException");
+ class_exists("\\Whoops\\Exception\\FrameCollection");
+ class_exists("\\Whoops\\Exception\\Frame");
+ class_exists("\\Whoops\\Exception\\Inspector");
+
+ set_error_handler(array($this, self::ERROR_HANDLER));
+ set_exception_handler(array($this, self::EXCEPTION_HANDLER));
+ register_shutdown_function(array($this, self::SHUTDOWN_HANDLER));
+
+ $this->isRegistered = true;
+ }
+
+ return $this;
+ }
+
+ /**
+ * Unregisters all handlers registered by this Whoops\Run instance
+ * @return Run
+ */
+ public function unregister()
+ {
+ if ($this->isRegistered) {
+ restore_exception_handler();
+ restore_error_handler();
+
+ $this->isRegistered = false;
+ }
+
+ return $this;
+ }
+
+ /**
+ * Should Whoops allow Handlers to force the script to quit?
+ * @param bool|int $exit
+ * @return bool
+ */
+ public function allowQuit($exit = null)
+ {
+ if (func_num_args() == 0) {
+ return $this->allowQuit;
+ }
+
+ return $this->allowQuit = (bool) $exit;
+ }
+
+ /**
+ * Silence particular errors in particular files
+ * @param array|string $patterns List or a single regex pattern to match
+ * @param int $levels Defaults to E_STRICT | E_DEPRECATED
+ * @return \Whoops\Run
+ */
+ public function silenceErrorsInPaths($patterns, $levels = 10240)
+ {
+ $this->silencedPatterns = array_merge(
+ $this->silencedPatterns,
+ array_map(
+ function ($pattern) use ($levels) {
+ return array(
+ "pattern" => $pattern,
+ "levels" => $levels,
+ );
+ },
+ (array) $patterns
+ )
+ );
+ return $this;
+ }
+
+ /*
+ * Should Whoops send HTTP error code to the browser if possible?
+ * Whoops will by default send HTTP code 500, but you may wish to
+ * use 502, 503, or another 5xx family code.
+ *
+ * @param bool|int $code
+ * @return int|false
+ */
+ public function sendHttpCode($code = null)
+ {
+ if (func_num_args() == 0) {
+ return $this->sendHttpCode;
+ }
+
+ if (!$code) {
+ return $this->sendHttpCode = false;
+ }
+
+ if ($code === true) {
+ $code = 500;
+ }
+
+ if ($code < 400 || 600 <= $code) {
+ throw new InvalidArgumentException(
+ "Invalid status code '$code', must be 4xx or 5xx"
+ );
+ }
+
+ return $this->sendHttpCode = $code;
+ }
+
+ /**
+ * Should Whoops push output directly to the client?
+ * If this is false, output will be returned by handleException
+ * @param bool|int $send
+ * @return bool
+ */
+ public function writeToOutput($send = null)
+ {
+ if (func_num_args() == 0) {
+ return $this->sendOutput;
+ }
+
+ return $this->sendOutput = (bool) $send;
+ }
+
+ /**
+ * Handles an exception, ultimately generating a Whoops error
+ * page.
+ *
+ * @param Exception $exception
+ * @return string Output generated by handlers
+ */
+ public function handleException(Exception $exception)
+ {
+ // Walk the registered handlers in the reverse order
+ // they were registered, and pass off the exception
+ $inspector = $this->getInspector($exception);
+
+ // Capture output produced while handling the exception,
+ // we might want to send it straight away to the client,
+ // or return it silently.
+ ob_start();
+
+ // Just in case there are no handlers:
+ $handlerResponse = null;
+
+ foreach (array_reverse($this->handlerStack) as $handler) {
+ $handler->setRun($this);
+ $handler->setInspector($inspector);
+ $handler->setException($exception);
+
+ $handlerResponse = $handler->handle($exception);
+
+ if (in_array($handlerResponse, array(Handler::LAST_HANDLER, Handler::QUIT))) {
+ // The Handler has handled the exception in some way, and
+ // wishes to quit execution (Handler::QUIT), or skip any
+ // other handlers (Handler::LAST_HANDLER). If $this->allowQuit
+ // is false, Handler::QUIT behaves like Handler::LAST_HANDLER
+ break;
+ }
+ }
+
+ $willQuit = $handlerResponse == Handler::QUIT && $this->allowQuit();
+
+ $output = ob_get_clean();
+
+ // If we're allowed to, send output generated by handlers directly
+ // to the output, otherwise, and if the script doesn't quit, return
+ // it so that it may be used by the caller
+ if ($this->writeToOutput()) {
+ // @todo Might be able to clean this up a bit better
+ // If we're going to quit execution, cleanup all other output
+ // buffers before sending our own output:
+ if ($willQuit) {
+ while (ob_get_level() > 0) {
+ ob_end_clean();
+ }
+ }
+
+ $this->writeToOutputNow($output);
+ }
+
+ if ($willQuit) {
+ exit(1);
+ }
+
+ return $output;
+ }
+
+ /**
+ * Converts generic PHP errors to \ErrorException
+ * instances, before passing them off to be handled.
+ *
+ * This method MUST be compatible with set_error_handler.
+ *
+ * @param int $level
+ * @param string $message
+ * @param string $file
+ * @param int $line
+ *
+ * @return bool|null
+ */
+ public function handleError($level, $message, $file = null, $line = null)
+ {
+ if ($level & error_reporting()) {
+ foreach ($this->silencedPatterns as $entry) {
+ $pathMatches = (bool) preg_match($entry["pattern"], $file);
+ $levelMatches = $level & $entry["levels"];
+ if ($pathMatches && $levelMatches) {
+ // Ignore the error, abort handling
+ return true;
+ }
+ }
+
+ $exception = new ErrorException($message, $level, 0, $file, $line);
+ if ($this->canThrowExceptions) {
+ throw $exception;
+ } else {
+ $this->handleException($exception);
+ }
+ }
+ }
+
+ /**
+ * Special case to deal with Fatal errors and the like.
+ */
+ public function handleShutdown()
+ {
+ // If we reached this step, we are in shutdown handler.
+ // An exception thrown in a shutdown handler will not be propagated
+ // to the exception handler. Pass that information along.
+ $this->canThrowExceptions = false;
+
+ $error = error_get_last();
+ if ($error && $this->isLevelFatal($error['type'])) {
+ // If there was a fatal error,
+ // it was not handled in handleError yet.
+ $this->handleError(
+ $error['type'],
+ $error['message'],
+ $error['file'],
+ $error['line']
+ );
+ }
+ }
+
+ /**
+ * In certain scenarios, like in shutdown handler, we can not throw exceptions
+ * @var bool
+ */
+ private $canThrowExceptions = true;
+
+ /**
+ * Echo something to the browser
+ * @param string $output
+ * @return $this
+ */
+ private function writeToOutputNow($output)
+ {
+ if ($this->sendHttpCode() && \Whoops\Util\Misc::canSendHeaders()) {
+ $httpCode = $this->sendHttpCode();
+
+ if (function_exists('http_response_code')) {
+ http_response_code($httpCode);
+ } else {
+ // http_response_code is added in 5.4.
+ // For compatibility with 5.3 we use the third argument in header call
+ // First argument must be a real header.
+ // If it is empty, PHP will ignore the third argument.
+ // If it is invalid, such as a single space, Apache will handle it well,
+ // but the PHP development server will hang.
+ // Setting a full status line would require us to hardcode
+ // string values for all different status code, and detect the protocol.
+ // which is an extra error-prone complexity.
+ header('X-Ignore-This: 1', true, $httpCode);
+ }
+ }
+
+ echo $output;
+
+ return $this;
+ }
+
+ private static function isLevelFatal($level)
+ {
+ $errors = E_ERROR;
+ $errors |= E_PARSE;
+ $errors |= E_CORE_ERROR;
+ $errors |= E_CORE_WARNING;
+ $errors |= E_COMPILE_ERROR;
+ $errors |= E_COMPILE_WARNING;
+ return ($level & $errors) > 0;
+ }
+}
diff --git a/library/Whoops/Util/Misc.php b/library/Whoops/Util/Misc.php
new file mode 100644
index 0000000..d38dbbf
--- /dev/null
+++ b/library/Whoops/Util/Misc.php
@@ -0,0 +1,44 @@
+
+ */
+
+namespace Whoops\Util;
+
+class Misc
+{
+ /**
+ * Can we at this point in time send HTTP headers?
+ *
+ * Currently this checks if we are even serving an HTTP request,
+ * as opposed to running from a command line.
+ *
+ * If we are serving an HTTP request, we check if it's not too late.
+ *
+ * @return bool
+ */
+ public static function canSendHeaders()
+ {
+ return isset($_SERVER["REQUEST_URI"]) && !headers_sent();
+ }
+
+ /**
+ * Translate ErrorException code into the represented constant.
+ *
+ * @param int $error_code
+ * @return string
+ */
+ public static function translateErrorCode($error_code)
+ {
+ $constants = get_defined_constants(true);
+ if (array_key_exists('Core' , $constants)) {
+ foreach ($constants['Core'] as $constant => $value) {
+ if (substr($constant, 0, 2) == 'E_' && $value == $error_code) {
+ return $constant;
+ }
+ }
+ }
+ return "E_UNKNOWN";
+ }
+}
diff --git a/library/Whoops/Util/TemplateHelper.php b/library/Whoops/Util/TemplateHelper.php
new file mode 100644
index 0000000..71690de
--- /dev/null
+++ b/library/Whoops/Util/TemplateHelper.php
@@ -0,0 +1,154 @@
+
+ */
+
+namespace Whoops\Util;
+
+/**
+ * Exposes useful tools for working with/in templates
+ */
+class TemplateHelper
+{
+ /**
+ * An array of variables to be passed to all templates
+ * @var array
+ */
+ private $variables = array();
+
+ /**
+ * Escapes a string for output in an HTML document
+ *
+ * @param string $raw
+ * @return string
+ */
+ public function escape($raw)
+ {
+ $flags = ENT_QUOTES;
+
+ // HHVM has all constants defined, but only ENT_IGNORE
+ // works at the moment
+ if (defined("ENT_SUBSTITUTE") && !defined("HHVM_VERSION")) {
+ $flags |= ENT_SUBSTITUTE;
+ } else {
+ // This is for 5.3.
+ // The documentation warns of a potential security issue,
+ // but it seems it does not apply in our case, because
+ // we do not blacklist anything anywhere.
+ $flags |= ENT_IGNORE;
+ }
+
+ return htmlspecialchars($raw, $flags, "UTF-8");
+ }
+
+ /**
+ * Escapes a string for output in an HTML document, but preserves
+ * URIs within it, and converts them to clickable anchor elements.
+ *
+ * @param string $raw
+ * @return string
+ */
+ public function escapeButPreserveUris($raw)
+ {
+ $escaped = $this->escape($raw);
+ return preg_replace(
+ "@([A-z]+?://([-\w\.]+[-\w])+(:\d+)?(/([\w/_\.#-]*(\?\S+)?[^\.\s])?)?)@",
+ "$1", $escaped
+ );
+ }
+
+ /**
+ * Convert a string to a slug version of itself
+ *
+ * @param string $original
+ * @return string
+ */
+ public function slug($original)
+ {
+ $slug = str_replace(" ", "-", $original);
+ $slug = preg_replace('/[^\w\d\-\_]/i', '', $slug);
+ return strtolower($slug);
+ }
+
+ /**
+ * Given a template path, render it within its own scope. This
+ * method also accepts an array of additional variables to be
+ * passed to the template.
+ *
+ * @param string $template
+ * @param array $additionalVariables
+ */
+ public function render($template, array $additionalVariables = null)
+ {
+ $variables = $this->getVariables();
+
+ // Pass the helper to the template:
+ $variables["tpl"] = $this;
+
+ if ($additionalVariables !== null) {
+ $variables = array_replace($variables, $additionalVariables);
+ }
+
+ call_user_func(function () {
+ extract(func_get_arg(1));
+ require func_get_arg(0);
+ }, $template, $variables);
+ }
+
+ /**
+ * Sets the variables to be passed to all templates rendered
+ * by this template helper.
+ *
+ * @param array $variables
+ */
+ public function setVariables(array $variables)
+ {
+ $this->variables = $variables;
+ }
+
+ /**
+ * Sets a single template variable, by its name:
+ *
+ * @param string $variableName
+ * @param mixd $variableValue
+ */
+ public function setVariable($variableName, $variableValue)
+ {
+ $this->variables[$variableName] = $variableValue;
+ }
+
+ /**
+ * Gets a single template variable, by its name, or
+ * $defaultValue if the variable does not exist
+ *
+ * @param string $variableName
+ * @param mixed $defaultValue
+ * @return mixed
+ */
+ public function getVariable($variableName, $defaultValue = null)
+ {
+ return isset($this->variables[$variableName]) ?
+ $this->variables[$variableName] : $defaultValue;
+ }
+
+ /**
+ * Unsets a single template variable, by its name
+ *
+ * @param string $variableName
+ */
+ public function delVariable($variableName)
+ {
+ unset($this->variables[$variableName]);
+ }
+
+ /**
+ * Returns all variables for this helper
+ *
+ * @return array
+ */
+ public function getVariables()
+ {
+ return $this->variables;
+ }
+}