Germania\Middleware\EmailExceptionMiddleware

Complexity

Total Complexity

13

Size/Duplication

Total Lines	186
Duplicated Lines	24.73 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

55.77%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	getMailer()	0	10	2
A	getMessage()	0	10	2
A	__construct()	0	10	1
A	process()	18	18	3
A	__invoke()	21	21	3
A	handleThrowable()	0	24	1
A	render()	0	5	1

<?php

namespace Germania\Middleware;

use Germania\Middleware\Exceptions\FactoryException;

use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Psr\Http\Server\MiddlewareInterface;

class EmailExceptionMiddleware implements MiddlewareInterface
{
    /**
     * @var callable
     */
    public $mailer_factory;


    /**
     * @var callable
     */
    public $message_factory;


    /**
     * @var string
     */
    public $app_name;


    /**
     * @var string
     */
    public $include_file;


    /**
     * @param string   $app_name        Name of application (used in email subject)
     * @param callable $mailer_factory  Factory that returns Swift_Mailer instance
     * @param callable $message_factory Factory that returns Swift_Message instance
     */
    public function __construct($app_name, callable $mailer_factory, callable $message_factory)
    {
        $this->app_name = $app_name;

        $this->mailer_factory = $mailer_factory;
        $this->message_factory = $message_factory;

        $include_path = realpath(__DIR__.'/../includes');
        $this->include_file = $include_path.'/exception.php';
    }



    
    /**
     * PSR-15 Single Pass
     *
     * @param  ServerRequestInterface  $request Server reuest instance
     * @param  RequestHandlerInterface $handler Request handler
     * @return ResponseInterface
     */
    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler) : ResponseInterface

This method seems to be duplicated in your project.

    {
        try {
            $response = $handler->handle($request);
            return $response;
        }
        // Executed only in PHP 7, will not match in PHP 5.x
        catch (\Throwable $e) {
            $this->handleThrowable($e);
            throw $e;
        }

        // Executed only in PHP 5.x, will not be reached in PHP 7
        catch (\Exception $e) {
            $this->handleThrowable($e);
            throw $e;
        }
    }

    

    /**
     * PSR-7 Double Pass
     *
     * Wrap $next callable in a try-catch block.
     * When an exception is caught, an email will be sent, and the execption will be re-thrown.
     *
     * @param RequestInterface   $request
     * @param ResponseInterface  $response
     * @param callable           $next
     *
     * @return ResponseInterface
     */
    public function __invoke(RequestInterface $request, ResponseInterface $response, callable $next)

This method seems to be duplicated in your project.

    {
        try {
            // Try to do business as usual...
            return $next($request, $response);
        }

        // Executed only in PHP 7, will not match in PHP 5.x
        catch (\Throwable $e) {
            $this->handleThrowable($e);
            throw $e;
        }

        // Executed only in PHP 5.x, will not be reached in PHP 7
        catch (\Exception $e) {
            $this->handleThrowable($e);
            throw $e;
        }

        // Anything else NOT caught here will bubble up.
    }


    /**
     * @param  \Exception|\Throwable $e
     */
    public function handleThrowable($e)
    {
        // Render email body, prepare some things
        $text    = $this->render($e, [

$e is of type object<Throwable>, but the function expects a object<Germania\Middleware\Exception>.

            'package' => array(
                'title'       => 'Germania KG · Middleware',
                'name'       => 'germania-kg/middleware',
                'packagist'  => 'https://packagist.org/packages/germania-kg/middleware',
                'middleware' => 'EmailExceptionMiddleware'
            )
        ]);
        $format  = 'text/html';
        $subject = sprintf("[%s] Exception %s", $this->app_name, get_class($e));

        // Create email message instance
        $message = $this->getMessage();
        $message->setContentType($format)
                ->setSubject($subject)
                ->setBody($text);

        // Create emailer instance + send
        $mailer = $this->getMailer();
        $mailer->send($message);
    }

    /**
     * Creates the email body.
     *
     * In this class, an include file creates a basic information table.
     * Override this method to use your own method.
     *
     * @param Exception $e
     *
     * @return string Exception explanation
     */
    public function render($e, array $context = array())
    {
        extract($context);
        return require $this->include_file;
    }


    /**
     * @return Swift_Mailer
     *
     * @throws FactoryException
     */
    public function getMailer()
    {
        $mailer_factory = $this->mailer_factory;
        $mailer = $mailer_factory();
        if (!$mailer instanceof \Swift_Mailer) {

The class Swift_Mailer does not exist. Did you forget a USE statement, or did you not list all dependencies?

            throw new FactoryException('Mailer factory must return Swift_Mailer instance.');
        }

        return $mailer;
    }


    /**
     * @return Swift_Message
     *
     * @throws FactoryException
     */
    public function getMessage()
    {
        $message_factory = $this->message_factory;
        $message = $message_factory();
        if (!$message instanceof \Swift_Message) {

The class Swift_Message does not exist. Did you forget a USE statement, or did you not list all dependencies?

            throw new FactoryException('Message factory must return Swift_Message instance.');
        }

        return $message;
    }
}