db/df9/PhpError_8php_source.html

 <?php
 namespace Slim\Handlers;

 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Slim\Http\Body;
 use UnexpectedValueException;

 class PhpError extends AbstractError
 {
     public function __invoke(ServerRequestInterface $request, ResponseInterface $response, \Throwable $error)
     {
         $contentType = $this->determineContentType($request);
         switch ($contentType) {
             case 'application/json':
                 $output = $this->renderJsonErrorMessage($error);
                 break;

             case 'text/xml':
             case 'application/xml':
                 $output = $this->renderXmlErrorMessage($error);
                 break;

             case 'text/html':
                 $output = $this->renderHtmlErrorMessage($error);
                 break;
             default:
                 throw new UnexpectedValueException('Cannot render unknown content type ' . $contentType);
         }

         $this->writeToErrorLog($error);

         $body = new Body(fopen('php://temp', 'r+'));
         $body->write($output);

         return $response
                 ->withStatus(500)
                 ->withHeader('Content-type', $contentType)
                 ->withBody($body);
     }

     protected function renderHtmlErrorMessage(\Throwable $error)
     {
         $title = 'Slim Application Error';

         if ($this->displayErrorDetails) {
             $html = '<p>The application could not run because of the following error:</p>';
             $html .= '<h2>Details</h2>';
             $html .= $this->renderHtmlError($error);

             while ($error = $error->getPrevious()) {
                 $html .= '<h2>Previous error</h2>';
                 $html .= $this->renderHtmlError($error);
             }
         } else {
             $html = '<p>A website error has occurred. Sorry for the temporary inconvenience.</p>';
         }

         $output = sprintf(
             "<html><head><meta http-equiv='Content-Type' content='text/html; charset=utf-8'>" .
             "<title>%s</title><style>body{margin:0;padding:30px;font:12px/1.5 Helvetica,Arial,Verdana," .
             "sans-serif;}h1{margin:0;font-size:48px;font-weight:normal;line-height:48px;}strong{" .
             "display:inline-block;width:65px;}</style></head><body><h1>%s</h1>%s</body></html>",
             $title,
             $title,
             $html
         );

         return $output;
     }

     protected function renderHtmlError(\Throwable $error)
     {
         $html = sprintf('<div><strong>Type:</strong> %s</div>', get_class($error));

         if (($code = $error->getCode())) {
             $html .= sprintf('<div><strong>Code:</strong> %s</div>', $code);
         }

         if (($message = $error->getMessage())) {
             $html .= sprintf('<div><strong>Message:</strong> %s</div>', htmlentities($message));
         }

         if (($file = $error->getFile())) {
             $html .= sprintf('<div><strong>File:</strong> %s</div>', $file);
         }

         if (($line = $error->getLine())) {
             $html .= sprintf('<div><strong>Line:</strong> %s</div>', $line);
         }

         if (($trace = $error->getTraceAsString())) {
             $html .= '<h2>Trace</h2>';
             $html .= sprintf('<pre>%s</pre>', htmlentities($trace));
         }

         return $html;
     }

     protected function renderJsonErrorMessage(\Throwable $error)
     {
         $json = [
             'message' => 'Slim Application Error',
         ];

         if ($this->displayErrorDetails) {
             $json['error'] = [];

             do {
                 $json['error'][] = [
                     'type' => get_class($error),
                     'code' => $error->getCode(),
                     'message' => $error->getMessage(),
                     'file' => $error->getFile(),
                     'line' => $error->getLine(),
                     'trace' => explode("\n", $error->getTraceAsString()),
                 ];
             } while ($error = $error->getPrevious());
         }

         return json_encode($json, JSON_PRETTY_PRINT);
     }

     protected function renderXmlErrorMessage(\Throwable $error)
     {
         $xml = "<error>\n  <message>Slim Application Error</message>\n";
         if ($this->displayErrorDetails) {
             do {
                 $xml .= "  <error>\n";
                 $xml .= "    <type>" . get_class($error) . "</type>\n";
                 $xml .= "    <code>" . $error->getCode() . "</code>\n";
                 $xml .= "    <message>" . $this->createCdataSection($error->getMessage()) . "</message>\n";
                 $xml .= "    <file>" . $error->getFile() . "</file>\n";
                 $xml .= "    <line>" . $error->getLine() . "</line>\n";
                 $xml .= "    <trace>" . $this->createCdataSection($error->getTraceAsString()) . "</trace>\n";
                 $xml .= "  </error>\n";
             } while ($error = $error->getPrevious());
         }
         $xml .= "</error>";

         return $xml;
     }

     private function createCdataSection($content)
     {
         return sprintf('<![CDATA[%s]]>', str_replace(']]>', ']]]]><![CDATA[>', $content));
     }
 }
Psr\Http\Message\ServerRequestInterface
Representation of an incoming, server-side HTTP request.
Definition: ServerRequestInterface.php:43

$request
foreach($paths as $path) $request
Definition: asyncclient.php:32

Sabre\VObject\$output
$output
Definition: mergeduplicates.php:36

$code
$code
Definition: example_050.php:99

Psr\Http\Message\ResponseInterface\withStatus
withStatus($code, $reasonPhrase='')
Return an instance with the specified status code and, optionally, reason phrase. ...

Slim\Handlers\PhpError\renderXmlErrorMessage
renderXmlErrorMessage(\Throwable $error)
Render XML error.
Definition: PhpError.php:175

fopen

UnexpectedValueException

ServerRequestInterface

Slim\Handlers\AbstractHandler\determineContentType
determineContentType(ServerRequestInterface $request)
Determine which content type we know about is wanted using Accept header.
Definition: AbstractHandler.php:40

Slim\Handlers\AbstractError\writeToErrorLog
writeToErrorLog($throwable)
Write to the error log if displayErrorDetails is false.
Definition: AbstractError.php:38

$message
catch(Exception $e) $message
Definition: saml2-logout.php:34

Slim\Handlers\PhpError\renderHtmlErrorMessage
renderHtmlErrorMessage(\Throwable $error)
Render HTML error page.
Definition: PhpError.php:72

Slim\Handlers\PhpError\createCdataSection
createCdataSection($content)
Returns a CDATA section with the given content.
Definition: PhpError.php:201

Psr\Http\Message\ResponseInterface
Representation of an outgoing, server-side response.
Definition: ResponseInterface.php:20

Slim\Handlers\AbstractError
Abstract Slim application error handler.
Definition: AbstractError.php:14

Body

Slim\Handlers\PhpError\renderHtmlError
renderHtmlError(\Throwable $error)
Render error as HTML.
Definition: PhpError.php:109

Slim\Handlers\PhpError\renderJsonErrorMessage
renderJsonErrorMessage(\Throwable $error)
Render JSON error.
Definition: PhpError.php:144

$xml
$xml
Definition: fetch_windows_zones.php:11

ResponseInterface

Slim\Http\Body
Body.
Definition: Body.php:19

php

$contentType
if($path[strlen($path) - 1]==='/') if(is_dir($path)) if(!file_exists($path)) if(preg_match('#\.php$#D', mb_strtolower($path, 'UTF-8'))) $contentType
Definition: module.php:144

Slim\Handlers
Slim Framework (https://slimframework.com)
Definition: AbstractError.php:9

$title
$title
Definition: memcachestat.tpl.php:28

Slim\Handlers\PhpError
Default Slim application error handler for PHP 7+ Throwables.
Definition: PhpError.php:22

Slim\Handlers\PhpError\__invoke
__invoke(ServerRequestInterface $request, ResponseInterface $response, \Throwable $error)
Invoke error handler.
Definition: PhpError.php:34

$response
$response
Definition: proxy_ylocal.php:39

$html
$html
Definition: example_001.php:87

Throwable