Application\Bootstrap

Complexity

Total Complexity

21

Size/Duplication

Total Lines	130
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	14

Test Coverage

Coverage

0%

Importance

Changes	1
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	forbidden()	0	18	4
B	preDispatch()	0	20	6
B	render()	0	16	5
A	end()	0	6	2
A	sendInfoHeaders()	0	17	2
A	sendErrors()	0	6	2

<?php
/**
 * @copyright Bluz PHP Team
 * @link      https://github.com/bluzphp/skeleton
 */

declare(strict_types=1);

namespace Application;

use Application\Auth;
use Bluz\Application\Application;
use Bluz\Application\Exception\ForbiddenException;
use Bluz\Auth\AuthException;
use Bluz\Controller\Controller;
use Bluz\Proxy\Auth as AuthProxy;
use Bluz\Proxy\Layout;
use Bluz\Proxy\Logger;
use Bluz\Proxy\Messages;
use Bluz\Proxy\Request;
use Bluz\Proxy\Response;
use Bluz\Proxy\Router;
use Bluz\Proxy\Session;

/**
 * Bootstrap
 *
 * @category Application
 * @package  Bootstrap
 *
 * @author   Anton Shevchuk
 * @created  20.07.11 17:38
 */
class Bootstrap extends Application

Since you have declared the constructor as private, maybe you should also declare the class as final.

{
    /**
     * {@inheritdoc}
     *
     * @param Controller $controller
     *
     * @return void
     * @throws \Application\Exception
     * @throws \Bluz\Auth\AuthException
     * @throws \InvalidArgumentException
     */
    protected function preDispatch($controller)
    {
        // example of setup default title
        Layout::title('Bluz Skeleton');

        if (!AuthProxy::getIdentity() && $controller->getModule() !== Router::getErrorModule()) {
            if ($token = Request::getCookie('Auth-Token')) {
                // try to login by token from cookies
                try {
                    Auth\Provider\Cookie::authenticate($token);
                } catch (AuthException $e) {
                    $this->getResponse()->setCookie('Auth-Token', '', 1, '/');
                }
            } elseif ($token = Request::getHeader('Auth-Token')) {
                // try to login by token from headers
                Auth\Provider\Token::authenticate($token);
            }
        }
        parent::preDispatch($controller);
    }

    /**
     * Denied access
     *
     * @param ForbiddenException $exception
     *
     * @return \Bluz\Controller\Controller|null
     */
    public function forbidden(ForbiddenException $exception)
    {
        // for AJAX and API calls (over JSON)
        $jsonOrApi = Request::isXmlHttpRequest()
            || (Request::checkAccept([Request::TYPE_HTML, Request::TYPE_JSON]) === Request::TYPE_JSON);

        // for guest, for requests
        if (!$jsonOrApi && !AuthProxy::getIdentity()) {
            // save URL to session and redirect make sense if presentation is null
            Session::set('rollback', Request::getUri()->__toString());
            // add error notice
            Messages::addError('You don\'t have permissions, please sign in');
            // redirect to Sign In page
            $url = Router::getUrl('users', 'signin');
            return $this->redirect($url);
        }
        return $this->error($exception);
    }

    /**
     * Render with debug headers
     *
     * @return void
     */
    public function render()
    {
        Logger::info('app:render');
        Logger::info('app:files:' . count(get_included_files()));

        if ($this->isDebug()) {
            if (!headers_sent()) {
                $this->sendInfoHeaders();
            }
            if (ob_get_level() > 0 && ob_get_length() > 0) {
                Logger::error('Output has been sent previously');
                return;
            }
        }
        parent::render();
    }

    /**
     * Finish it
     *
     * @return void
     */
    public function end()
    {
        if ($errors = Logger::get('error')) {
            $this->sendErrors($errors);
        }
    }

    /**
     * Send information headers
     *
     * @return void
     */
    protected function sendInfoHeaders()

sendInfoHeaders uses the super-global variable $_SERVER which is generally not recommended.

    {
        $debugString = sprintf(
            '%fsec; %skb',
            microtime(true) - $_SERVER['REQUEST_TIME_FLOAT'],
            ceil(memory_get_usage() / 1024)
        );
        $debugString .= '; ' . Request::getModule() . '/' . Request::getController();

        Response::setHeader('Bluz-Debug', $debugString);

        if ($info = Logger::get('info')) {
            Response::setHeader('Bluz-Bar', json_encode($info));
        } else {
            Response::setHeader('Bluz-Bar', '{"!":"Logger is disabled"}');
        }
    }

    /**
     * sendErrorBody
     *
     * @param  array $errors
     *
     * @return void
     */
    protected function sendErrors($errors)
    {
        foreach ($errors as $message) {
            errorLog(new \ErrorException($message, 0, E_USER_ERROR));
        }
    }
}