Application::process() - Code Metrics - Inspection of "Migrate to PHP 7.1" - bluzphp/framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#451)

by Anton

created 2017-11-16 09:26 UTC

Application::process() A

↳ Parent: Application

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	4
nc	1
nop	0
dl	0
loc	6
ccs	5
cts	5
cp	1
crap	1
rs	9.4285
c	0
b	0
f	0

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

declare(strict_types=1);

namespace Bluz\Application;

use Bluz\Application\Exception\ApplicationException;
use Bluz\Http\Exception\ForbiddenException;
use Bluz\Http\Exception\NotAcceptableException;
use Bluz\Http\Exception\NotAllowedException;
use Bluz\Http\Exception\RedirectException;
use Bluz\Common;
use Bluz\Common\Exception\CommonException;
use Bluz\Common\Exception\ComponentException;
use Bluz\Controller\Controller;
use Bluz\Controller\ControllerException;
use Bluz\Proxy\Config;
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;
use Bluz\Proxy\Translator;
use Bluz\Request\RequestFactory;
use Bluz\Response\Response as ResponseInstance;
use Zend\Diactoros\ServerRequest;

/**
 * Application
 *
 * @package  Bluz\Application
 * @link     https://github.com/bluzphp/framework/wiki/Application
 * @author   Anton Shevchuk
 * @created  06.07.11 16:25
 *
 * @method Controller error(\Exception $exception)
 * @method mixed forbidden(ForbiddenException $exception)
 * @method null redirect(RedirectException $url)
 */
class Application

{
    use Common\Helper;
    use Common\Singleton;

    /**
     * @var string Environment name
     */
    protected $environment = 'production';

    /**
     * @var string Application path
     */
    protected $path;

    /**
     * @var bool Debug application flag
     */
    protected $debugFlag = false;

    /**
     * @var bool Layout usage flag
     */
    protected $layoutFlag = true;

    /**
     * Get application environment
     *
     * @return string
     */
    public function getEnvironment() : string
    {
        return $this->environment;
    }

    /**
     * Get path to Application
     *
     * @return string
     */
    public function getPath() : string
    {
        if (!$this->path) {
            if (defined('PATH_APPLICATION')) {
                $this->path = PATH_APPLICATION;
            } else {
                $reflection = new \ReflectionClass($this);
                // 3 level up
                $this->path = dirname($reflection->getFileName(), 3);
            }
        }
        return $this->path;
    }

    /**
     * Return Debug flag
     *
     * @return bool
     */
    public function isDebug() : bool
    {
        return $this->debugFlag;
    }

    /**
     * Return/setup Layout Flag
     *
     * @param  bool|null $flag
     *
     * @return bool
     */
    public function useLayout($flag = null) : bool
    {
        if (is_bool($flag)) {
            $this->layoutFlag = $flag;
        }

        return $this->layoutFlag;
    }

    /**
     * Initialize system packages
     *
     * @param  string $environment
     *
     * @throws ApplicationException
     * @return void
     */
    public function init($environment = 'production') : void
    {
        $this->environment = $environment;

        try {
            // initial default helper path
            $this->addHelperPath(__DIR__ . '/Helper/');

            // init Config
            $this->initConfig();

            // first log message
            Logger::info('app:init');

            // init Session, start inside class (if needed)
            Session::getInstance();

            // init Messages
            Messages::getInstance();

            // init Translator
            Translator::getInstance();

            // init Request
            $this->initRequest();

            // init Response
            $this->initResponse();

            // init Router
            $this->initRouter();
        } catch (\Exception $e) {
            throw new ApplicationException("Application can't be loaded: " . $e->getMessage());
        }
    }

    /**
     * Initial Request instance
     *
     * @return void
     */
    protected function initConfig() : void
    {
        Config::getInstance();

        // setup configuration for current environment
        if ($debug = Config::getData('debug')) {
            $this->debugFlag = (bool)$debug;
        }

        // initial php settings
        if ($ini = Config::getData('php')) {
            foreach ($ini as $key => $value) {
                $result = ini_set($key, $value);
                Logger::info('app:init:php:' . $key . ':' . ($result ?: '---'));
            }
        }
    }

    /**
     * Initial Request instance
     *
     * @return void
     * @throws \InvalidArgumentException
     */
    protected function initRequest() : void
    {
        $request = RequestFactory::fromGlobals();

        Request::setInstance($request);
    }

    /**
     * Initial Response instance
     *
     * @return void
     */
    protected function initResponse() : void
    {
        $response = new ResponseInstance();

        Response::setInstance($response);
    }

    /**
     * Initial Router instance
     *
     * @return void
     */
    protected function initRouter() : void
    {
        $router = new \Bluz\Router\Router();
        $router->setOptions(Config::getData('router'));

        Router::setInstance($router);
    }

    /**
     * Get Response instance
     *
     * @return \Bluz\Response\Response
     */
    public function getResponse() : ResponseInstance
    {
        return Response::getInstance();
    }

    /**
     * Get Request instance
     *
     * @return \Zend\Diactoros\ServerRequest
     */
    public function getRequest() : ServerRequest
    {
        return Request::getInstance();
    }

    /**
     * Run application
     *
     * @return void
     * @throws ApplicationException
     */
    public function run() : void
    {
        $this->process();
        $this->render();
        $this->end();
    }

    /**
     * Process application
     *
     * Note:
     * - Why you don't use "X-" prefix for custom headers?
     * - Because it deprecated ({@link http://tools.ietf.org/html/rfc6648})
     *
     * @return void
     * @throws ApplicationException
     */
    public function process() : void
    {
        $this->preProcess();
        $this->doProcess();
        $this->postProcess();
    }

    /**
     * Extension point: pre process
     *
     * - Router processing
     * - Analyse request headers
     *
     * @return void
     * @throws ApplicationException
     */
    protected function preProcess() : void
    {
        Router::process();

        // disable Layout for XmlHttpRequests
        if (Request::isXmlHttpRequest()) {
            $this->layoutFlag = false;
        }

        // switch to JSON response based on Accept header
        if (Request::checkAccept([Request::TYPE_HTML, Request::TYPE_JSON]) === Request::TYPE_JSON) {
            $this->layoutFlag = false;
            Response::setType('JSON');
        }
    }

    /**
     * Do process
     *
     * - Dispatch controller
     * - Exceptions handling
     * - Setup layout
     * - Setup response body
     *
     * @return void
     */
    protected function doProcess() : void
    {
        $module = Request::getModule();
        $controller = Request::getController();
        $params = Request::getParams();

        try {
            // try to dispatch controller
            $result = $this->dispatch($module, $controller, $params);
        } catch (ForbiddenException $e) {
            // dispatch default error controller
            $result = $this->forbidden($e);
        } catch (RedirectException $e) {
            // should return `null` for disable output and setup redirect headers
            $result = $this->redirect($e);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
        } catch (\Exception $e) {
            // dispatch default error controller
            $result = $this->error($e);
        }

        // setup layout, if needed
        if ($this->useLayout()) {
            // render view to layout
            // needed for headScript and headStyle helpers
            Layout::setContent($result->render());
            Response::setBody(Layout::getInstance());
        } else {
            Response::setBody($result);
        }
    }

    /**
     * Extension point: post process
     *
     * @return void
     */
    protected function postProcess() : void
    {
        // nothing
    }

    /**
     * Dispatch controller with params
     *
     * Call dispatch from any \Bluz\Package
     *     Application::getInstance()->dispatch($module, $controller, array $params);
     *
     * @param  string $module
     * @param  string $controller
     * @param  array  $params
     *
     * @return Controller
     * @throws ComponentException
     * @throws CommonException
     * @throws ControllerException
     * @throws ForbiddenException
     * @throws NotAcceptableException
     * @throws NotAllowedException
     */
    public function dispatch($module, $controller, array $params = []) : Controller
    {
        $instance = new Controller($module, $controller, $params);

        Logger::info("app:dispatch:>>>: $module/$controller");
        $this->preDispatch($instance);

        Logger::info("app:dispatch:===: $module/$controller");
        $this->doDispatch($instance);

        Logger::info("app:dispatch:<<<: $module/$controller");
        $this->postDispatch($instance);

        return $instance;
    }

    /**
     * Extension point: pre dispatch
     *
     * @param  Controller $controller
     *
     * @return void
     * @throws ComponentException
     * @throws ForbiddenException
     * @throws NotAcceptableException
     * @throws NotAllowedException
     */
    protected function preDispatch($controller) : void
    {
        // check HTTP method
        $controller->checkHttpMethod();

        // check ACL privileges
        $controller->checkPrivilege();

        // check HTTP Accept header
        $controller->checkHttpAccept();
    }

    /**
     * Do dispatch
     *
     * @param  Controller $controller
     *
     * @return void
     * @throws ComponentException
     * @throws ControllerException
     */
    protected function doDispatch($controller) : void
    {
        // run controller
        $controller->run();
    }

    /**
     * Extension point: post dispatch
     *
     * @param  Controller $controller
     *
     * @return void
     */
    protected function postDispatch($controller) : void

    {
        // nothing by default
    }

    /**
     * Render, is send Response
     *
     * @return void
     */
    public function render() : void
    {
        Response::send();
    }

    /**
     * Extension point: finally method
     *
     * @return void
     */
    public function end() : void
    {
        // nothing
    }
}


1		<?php
2		/**
3		* Bluz Framework Component
4		*
5		* @copyright Bluz PHP Team
6		* @link https://github.com/bluzphp/framework
7		*/
8
9		declare(strict_types=1);
10
11		namespace Bluz\Application;
12
13		use Bluz\Application\Exception\ApplicationException;
14		use Bluz\Http\Exception\ForbiddenException;
15		use Bluz\Http\Exception\NotAcceptableException;
16		use Bluz\Http\Exception\NotAllowedException;
17		use Bluz\Http\Exception\RedirectException;
18		use Bluz\Common;
19		use Bluz\Common\Exception\CommonException;
20		use Bluz\Common\Exception\ComponentException;
21		use Bluz\Controller\Controller;
22		use Bluz\Controller\ControllerException;
23		use Bluz\Proxy\Config;
24		use Bluz\Proxy\Layout;
25		use Bluz\Proxy\Logger;
26		use Bluz\Proxy\Messages;
27		use Bluz\Proxy\Request;
28		use Bluz\Proxy\Response;
29		use Bluz\Proxy\Router;
30		use Bluz\Proxy\Session;
31		use Bluz\Proxy\Translator;
32		use Bluz\Request\RequestFactory;
33		use Bluz\Response\Response as ResponseInstance;
34		use Zend\Diactoros\ServerRequest;
35
36		/**
37		* Application
38		*
39		* @package Bluz\Application
40		* @link https://github.com/bluzphp/framework/wiki/Application
41		* @author Anton Shevchuk
42		* @created 06.07.11 16:25
43		*
44		* @method Controller error(\Exception $exception)
45		* @method mixed forbidden(ForbiddenException $exception)
46		* @method null redirect(RedirectException $url)
47		*/
48		class Application
		0 ignored issues – show Coding Style introduced 2017-06-30 10:54 UTC by Report Bug Copy Issue Report Since you have declared the constructor as private, maybe you should also declare the class as final. Loading history...
49		{
50		use Common\Helper;
51		use Common\Singleton;
52
53		/**
54		* @var string Environment name
55		*/
56		protected $environment = 'production';
57
58		/**
59		* @var string Application path
60		*/
61		protected $path;
62
63		/**
64		* @var bool Debug application flag
65		*/
66		protected $debugFlag = false;
67
68		/**
69		* @var bool Layout usage flag
70		*/
71		protected $layoutFlag = true;
72
73		/**
74		* Get application environment
75		*
76		* @return string
77		*/
78	585	public function getEnvironment() : string
79		{
80	585	return $this->environment;
81		}
82
83		/**
84		* Get path to Application
85		*
86		* @return string
87		*/
88	585	public function getPath() : string
89		{
90	585	if (!$this->path) {
91	579	if (defined('PATH_APPLICATION')) {
92	579	$this->path = PATH_APPLICATION;
93		} else {
94		$reflection = new \ReflectionClass($this);
95		// 3 level up
96		$this->path = dirname($reflection->getFileName(), 3);
97		}
98		}
99	585	return $this->path;
100		}
101
102		/**
103		* Return Debug flag
104		*
105		* @return bool
106		*/
107	2	public function isDebug() : bool
108		{
109	2	return $this->debugFlag;
110		}
111
112		/**
113		* Return/setup Layout Flag
114		*
115		* @param bool\|null $flag
116		*
117		* @return bool
118		*/
119	35	public function useLayout($flag = null) : bool
120		{
121	35	if (is_bool($flag)) {
122	28	$this->layoutFlag = $flag;
123		}
124
125	35	return $this->layoutFlag;
126		}
127
128		/**
129		* Initialize system packages
130		*
131		* @param string $environment
132		*
133		* @throws ApplicationException
134		* @return void
135		*/
136	580	public function init($environment = 'production') : void
137		{
138	580	$this->environment = $environment;
139
140		try {
141		// initial default helper path
142	580	$this->addHelperPath(__DIR__ . '/Helper/');
143
144		// init Config
145	580	$this->initConfig();
146
147		// first log message
148	580	Logger::info('app:init');
149
150		// init Session, start inside class (if needed)
151	580	Session::getInstance();
152
153		// init Messages
154	580	Messages::getInstance();
155
156		// init Translator
157	580	Translator::getInstance();
158
159		// init Request
160	580	$this->initRequest();
161
162		// init Response
163	580	$this->initResponse();
164
165		// init Router
166	580	$this->initRouter();
167		} catch (\Exception $e) {
168		throw new ApplicationException("Application can't be loaded: " . $e->getMessage());
169		}
170	580	}
171
172		/**
173		* Initial Request instance
174		*
175		* @return void
176		*/
177	580	protected function initConfig() : void
178		{
179	580	Config::getInstance();
180
181		// setup configuration for current environment
182	580	if ($debug = Config::getData('debug')) {
183		$this->debugFlag = (bool)$debug;
184		}
185
186		// initial php settings
187	580	if ($ini = Config::getData('php')) {
188		foreach ($ini as $key => $value) {
189		$result = ini_set($key, $value);
190		Logger::info('app:init:php:' . $key . ':' . ($result ?: '---'));
191		}
192		}
193	580	}
194
195		/**
196		* Initial Request instance
197		*
198		* @return void
199		* @throws \InvalidArgumentException
200		*/
201	580	protected function initRequest() : void
202		{
203	580	$request = RequestFactory::fromGlobals();
204
205	580	Request::setInstance($request);
206	580	}
207
208		/**
209		* Initial Response instance
210		*
211		* @return void
212		*/
213	580	protected function initResponse() : void
214		{
215	580	$response = new ResponseInstance();
216
217	580	Response::setInstance($response);
218	580	}
219
220		/**
221		* Initial Router instance
222		*
223		* @return void
224		*/
225	580	protected function initRouter() : void
226		{
227	580	$router = new \Bluz\Router\Router();
228	580	$router->setOptions(Config::getData('router'));
229
230	580	Router::setInstance($router);
231	580	}
232
233		/**
234		* Get Response instance
235		*
236		* @return \Bluz\Response\Response
237		*/
238	3	public function getResponse() : ResponseInstance
239		{
240	3	return Response::getInstance();
241		}
242
243		/**
244		* Get Request instance
245		*
246		* @return \Zend\Diactoros\ServerRequest
247		*/
248	1	public function getRequest() : ServerRequest
249		{
250	1	return Request::getInstance();
251		}
252
253		/**
254		* Run application
255		*
256		* @return void
257		* @throws ApplicationException
258		*/
259	1	public function run() : void
260		{
261	1	$this->process();
262	1	$this->render();
263	1	$this->end();
264	1	}
265
266		/**
267		* Process application
268		*
269		* Note:
270		* - Why you don't use "X-" prefix for custom headers?
271		* - Because it deprecated ({@link http://tools.ietf.org/html/rfc6648})
272		*
273		* @return void
274		* @throws ApplicationException
275		*/
276	9	public function process() : void
277		{
278	9	$this->preProcess();
279	9	$this->doProcess();
280	9	$this->postProcess();
281	9	}
282
283		/**
284		* Extension point: pre process
285		*
286		* - Router processing
287		* - Analyse request headers
288		*
289		* @return void
290		* @throws ApplicationException
291		*/
292	9	protected function preProcess() : void
293		{
294	9	Router::process();
295
296		// disable Layout for XmlHttpRequests
297	9	if (Request::isXmlHttpRequest()) {
298	2	$this->layoutFlag = false;
299		}
300
301		// switch to JSON response based on Accept header
302	9	if (Request::checkAccept([Request::TYPE_HTML, Request::TYPE_JSON]) === Request::TYPE_JSON) {
303	1	$this->layoutFlag = false;
304	1	Response::setType('JSON');
305		}
306	9	}
307
308		/**
309		* Do process
310		*
311		* - Dispatch controller
312		* - Exceptions handling
313		* - Setup layout
314		* - Setup response body
315		*
316		* @return void
317		*/
318		protected function doProcess() : void
319		{
320		$module = Request::getModule();
321		$controller = Request::getController();
322		$params = Request::getParams();
323
324		try {
325		// try to dispatch controller
326		$result = $this->dispatch($module, $controller, $params);
327		} catch (ForbiddenException $e) {
328		// dispatch default error controller
329		$result = $this->forbidden($e);
330		} catch (RedirectException $e) {
331		// should return `null` for disable output and setup redirect headers
332		$result = $this->redirect($e);
		0 ignored issues – show Bug introduced 2017-11-13 08:25 UTC by Report Bug Copy Issue Report Are you sure the assignment to `$result` is correct as `$this->redirect($e)` (which targets `Bluz\Application\Application::redirect()`) seems to always return null. This check looks for function or method calls that always return null and whose return value is assigned to a variable. class A { function getObject() { return null; } } $a = new A(); $object = $a->getObject(); The method `getObject()` can return nothing but null, so it makes no sense to assign that value to a variable. The reason is most likely that a function or method is imcomplete or has been reduced for debug purposes. Loading history...
333		} catch (\Exception $e) {
334		// dispatch default error controller
335		$result = $this->error($e);
336		}
337
338		// setup layout, if needed
339		if ($this->useLayout()) {
340		// render view to layout
341		// needed for headScript and headStyle helpers
342		Layout::setContent($result->render());
343		Response::setBody(Layout::getInstance());
344		} else {
345		Response::setBody($result);
346		}
347		}
348
349		/**
350		* Extension point: post process
351		*
352		* @return void
353		*/
354	9	protected function postProcess() : void
355		{
356		// nothing
357	9	}
358
359		/**
360		* Dispatch controller with params
361		*
362		* Call dispatch from any \Bluz\Package
363		* Application::getInstance()->dispatch($module, $controller, array $params);
364		*
365		* @param string $module
366		* @param string $controller
367		* @param array $params
368		*
369		* @return Controller
370		* @throws ComponentException
371		* @throws CommonException
372		* @throws ControllerException
373		* @throws ForbiddenException
374		* @throws NotAcceptableException
375		* @throws NotAllowedException
376		*/
377	41	public function dispatch($module, $controller, array $params = []) : Controller
378		{
379	41	$instance = new Controller($module, $controller, $params);
380
381	41	Logger::info("app:dispatch:>>>: $module/$controller");
382	41	$this->preDispatch($instance);
383
384	40	Logger::info("app:dispatch:===: $module/$controller");
385	40	$this->doDispatch($instance);
386
387	38	Logger::info("app:dispatch:<<<: $module/$controller");
388	38	$this->postDispatch($instance);
389
390	38	return $instance;
391		}
392
393		/**
394		* Extension point: pre dispatch
395		*
396		* @param Controller $controller
397		*
398		* @return void
399		* @throws ComponentException
400		* @throws ForbiddenException
401		* @throws NotAcceptableException
402		* @throws NotAllowedException
403		*/
404	41	protected function preDispatch($controller) : void
405		{
406		// check HTTP method
407	41	$controller->checkHttpMethod();
408
409		// check ACL privileges
410	40	$controller->checkPrivilege();
411
412		// check HTTP Accept header
413	40	$controller->checkHttpAccept();
414	40	}
415
416		/**
417		* Do dispatch
418		*
419		* @param Controller $controller
420		*
421		* @return void
422		* @throws ComponentException
423		* @throws ControllerException
424		*/
425	40	protected function doDispatch($controller) : void
426		{
427		// run controller
428	40	$controller->run();
429	38	}
430
431		/**
432		* Extension point: post dispatch
433		*
434		* @param Controller $controller
435		*
436		* @return void
437		*/
438	38	protected function postDispatch($controller) : void
		0 ignored issues – show Unused Code introduced 2017-11-13 08:25 UTC by Report Bug Copy Issue Report The parameter `$controller` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
439		{
440		// nothing by default
441	38	}
442
443		/**
444		* Render, is send Response
445		*
446		* @return void
447		*/
448	1	public function render() : void
449		{
450	1	Response::send();
451	1	}
452
453		/**
454		* Extension point: finally method
455		*
456		* @return void
457		*/
458	1	public function end() : void
459		{
460		// nothing
461	1	}
462		}
463

bluzphp / framework

Pull Request — master (#451)

Application::process() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like