Psr7Middlewares\Middleware\Whoops

Complexity

Total Complexity

10

Size/Duplication

Total Lines	117
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	7

Importance

Changes	4
Bugs	3	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	2
A	whoops()	0	6	1
A	catchErrors()	0	6	1
B	__invoke()	0	27	3
A	getWhoopsInstance()	0	20	3

<?php

namespace Psr7Middlewares\Middleware;

use Psr7Middlewares\Middleware;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\ResponseInterface;
use Whoops\Run;
use Whoops\Handler\PrettyPageHandler;
use Whoops\Handler\PlainTextHandler;
use Whoops\Handler\JsonResponseHandler;

/**
 * Middleware to use whoops as error handler.
 */
class Whoops
{
    /**
     * @var Run|null To handle errors using whoops
     */
    private $whoops;

    /**
     * @var bool Whether catch errors or not
     */
    private $catchErrors = true;

    /**
     * Constructor.Set the whoops instance.
     *
     * @param Run $whoops
     */
    public function __construct(Run $whoops = null)
    {
        if ($whoops !== null) {
            $this->whoops($whoops);
        }
    }

    /**
     * Set an instance of Whoops.
     *
     * @param Run $whoops
     *
     * @return self
     */
    public function whoops(Run $whoops)
    {
        $this->whoops = $whoops;

        return $this;
    }

    /**
     * Whether catch errors or not.
     *
     * @param bool $catchErrors
     *
     * @return self
     */
    public function catchErrors($catchErrors = true)
    {
        $this->catchErrors = (bool) $catchErrors;

        return $this;
    }

    /**
     * Execute the middleware.
     *
     * @param ServerRequestInterface $request
     * @param ResponseInterface      $response
     * @param callable               $next
     *
     * @return ResponseInterface
     */
    public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $next)
    {
        $whoops = $this->getWhoopsInstance($request);

        //Catch errors means register whoops globally
        if ($this->catchErrors) {
            $whoops->register();
        }

        try {
            $response = $next($request, $response);
        } catch (\Exception $exception) {
            $method = Run::EXCEPTION_HANDLER;

            $whoops->allowQuit(false);
            $whoops->writeToOutput(false);

            $body = Middleware::createStream();
            $body->write($whoops->$method($exception));

            $response = $response->withStatus(500)->withBody($body);
        }

        $whoops->unregister();

        return $response;
    }

    /**
     * Returns the whoops instance or create one.
     * 
     * @param ServerRequestInterface $request
     *
     * @return Run
     */
    private function getWhoopsInstance(ServerRequestInterface $request)
    {
        if ($this->whoops) {
            return $this->whoops;
        }

        $whoops = new Run();

        //Is ajax?
        if (strtolower($request->getHeaderLine('X-Requested-With')) === 'xmlhttprequest') {
            $whoops->pushHandler(new JsonResponseHandler());

new \Whoops\Handler\JsonResponseHandler() is of type object<Whoops\Handler\JsonResponseHandler>, but the function expects a callable.

        } else {
            $whoops->pushHandler(new PrettyPageHandler());

new \Whoops\Handler\PrettyPageHandler() is of type object<Whoops\Handler\PrettyPageHandler>, but the function expects a callable.

        }

        //Command line
        $whoops->pushHandler(new PlainTextHandler());

new \Whoops\Handler\PlainTextHandler() is of type object<Whoops\Handler\PlainTextHandler>, but the function expects a callable.

        return $whoops;
    }
}