Errors::defaultErrorRender() - Code Metrics - Inspection of "Move and improve skeleton directory" - bfw-systems/bfw - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 3.0 ( de1771...791612 )

by Vermeulen

created 2018-04-06 14:10 UTC

Errors::defaultErrorRender() C

↳ Parent: Project

Complexity

Conditions	10
Paths	5

Size

Total Lines	67
Code Lines	30

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	67
rs	6.1506
cc	10
eloc	30
nc	5
nop	5

How to fix Long Method Complexity

<?php

namespace BFW\Core;

/**
 * Class used to have a personnal message/page for errors and exceptions
 */
class Errors
{
    /**
     * Constructeur
     */
    public function __construct()
    {
        //Find and create the handler for errors
        $this->defineErrorHandler();
        
        //Find and create the handler for exceptions
        $this->defineExceptionHandler();
    }
    
    /**
     * Find and create the handler for errors
     * 
     * @return void
     */
    protected function defineErrorHandler()
    {
        $errorRender = $this->obtainErrorRender();
        
        //If not render to use
        if ($errorRender === false) {
            return;
        }

        //add the handler for errors
        set_error_handler([$this, 'errorHandler']);
    }
    
    /**
     * Find and create the handler for exceptions
     * 
     * @return type
     */
    protected function defineExceptionHandler()
    {
        $exceptionRender = $this->obtainExceptionRender();
        
        //If not render to use
        if ($exceptionRender === false) {
            return;
        }
        
        //add the handler for exceptions
        set_exception_handler([$this, 'exceptionHandler']);
    }
    
    /**
     * Get the error render from config for cli or default
     * 
     * @return boolean|array Render infos
     *  Boolean : false if no render to use
     *  Array   : Infos from config
     */
    protected function obtainErrorRender()
    {
        $app        = \BFW\Application::getInstance();
        $renderFcts = $app->getConfig()->getValue('errorRenderFct');
        
        return $this->defineRenderToUse($renderFcts);
    }
    
    /**
     * Get the exception render from config for cli or default
     * 
     * @return boolean|array Render infos
     *  Boolean : false if no render to use
     *  Array   : Infos from config
     */
    protected function obtainExceptionRender()
    {
        $app        = \BFW\Application::getInstance();
        $renderFcts = $app->getConfig()->getValue('exceptionRenderFct');
        
        return $this->defineRenderToUse($renderFcts);
    }
    
    /**
     * Find the render to use with the config
     * If cli render is not define, it's use the default render.
     * 
     * @param array $renderConfig : Render infos from config
     * 
     * @return boolean|array : Render to use
     *  Boolean : false if is no enabled or if no render is defined
     *  Array : The render to use
     */
    protected function defineRenderToUse($renderConfig)
    {
        //Check enabled
        if ($renderConfig['enabled'] === false) {
            return false;
        }
        
        //The cli render if cli mode
        if (PHP_SAPI === 'cli' && isset($renderConfig['cli'])) {
            return $renderConfig['cli'];
        }
        
        //The default render or cli if cli mode and no cli render configured
        if (isset($renderConfig['default'])) {
            return $renderConfig['default'];
        }
        
        return false;
    }
    
    /**
     * The default exception handler included in BFW
     * 
     * @param \Exception $exception : Exception informations
     * 
     * @return void
     */
    public function exceptionHandler($exception)
    {
        $errorRender = $this->obtainExceptionRender();
        
        $this->callRender(
            $errorRender,
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            'Exception Uncaught', 
            $exception->getMessage(), 
            $exception->getFile(), 
            $exception->getLine(), 
            $exception->getTrace()
        );
    }
    
    /**
     * The default error handler included in BFW
     * 
     * @param integer $errSeverity : Error severity
     * @param string  $errMsg : Error message
     * @param string  $errFile : File where the error is triggered
     * @param integer $errLine : Line where the error is triggered
     * 
     * @return void
     */
    public function errorHandler(
        $errSeverity,
        $errMsg,
        $errFile,
        $errLine
    ) {
        $errType     = $this->obtainErrorType($errSeverity);
        $errorRender = $this->obtainErrorRender();
        
        //Call the "callRender" method for this class (or child class)
        $this->callRender(
            $errorRender,
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            $errType,
            $errMsg,
            $errFile,
            $errLine,
            debug_backtrace()
        );
    }
    
    /**
     * Call the personnal class-method or function declared on config when
     * an exception or an error is triggered.
     * 
     * @param array   $renderInfos : Infos from config
     * @param string  $errType : Human readable error severity
     * @param string  $errMsg : Error/exception message
     * @param string  $errFile : File where the error/exception is triggered
     * @param integer $errLine : Line where the error/exception is triggered
     * @param array   $backtrace : Error/exception backtrace
     * 
     * @return void
     */
    protected function callRender(
        $renderInfos,
        $errType,
        $errMsg,
        $errFile,
        $errLine,
        $backtrace
    ) {
        $this->saveIntoPhpLog($errType, $errMsg, $errFile, $errLine);
        
        $class  = $renderInfos['class'];
        $method = $renderInfos['method'];
        
        //If is a class, call "$class::$method" (compatibility 5.x)
        if (!empty($class)) {
            $class::$method(
                $errType,
                $errMsg,
                $errFile,
                $errLine,
                $backtrace
            );
            
            return;
        }
        
        //If is not a class, it's a function.
        $method(
            $errType,
            $errMsg,
            $errFile,
            $errLine,
            $backtrace
        );
    }
    
    /**
     * Save the error into the PHP log
     * 
     * @param string  $errType : Human readable error severity
     * @param string  $errMsg : Error/exception message
     * @param string  $errFile : File where the error/exception is triggered
     * @param integer $errLine : Line where the error/exception is triggered
     * 
     * @return void
     */
    protected function saveIntoPhpLog(
        $errType,
        $errMsg,
        $errFile,
        $errLine
    ) {
        error_log(
            'Error detected : '.$errType.' '.$errMsg
            .' at '.$errFile.':'.$errLine
        );
    }
    
    /**
     * Map array to have a human readable severity.
     * 
     * @see http://fr2.php.net/manual/fr/function.set-error-handler.php#113567
     * 
     * @param int $errSeverity : The error severity with PHP constant
     * 
     * @return string
     */
    protected function obtainErrorType($errSeverity)
    {
        $errorMap = [
            E_ERROR             => 'Fatal',
            E_CORE_ERROR        => 'Fatal',
            E_USER_ERROR        => 'Fatal',
            E_COMPILE_ERROR     => 'Fatal',
            E_RECOVERABLE_ERROR => 'Fatal',
            E_WARNING           => 'Warning',
            E_CORE_WARNING      => 'Warning',
            E_USER_WARNING      => 'Warning',
            E_COMPILE_WARNING   => 'Warning',
            E_PARSE             => 'Parse',
            E_NOTICE            => 'Notice',
            E_USER_NOTICE       => 'Notice',
            E_STRICT            => 'Strict',
            E_DEPRECATED        => 'Deprecated',
            E_USER_DEPRECATED   => 'Deprecated'
        ];

        //Default value if the error is not found in the map array
        $errType = 'Unknown';
        
        //Search in map array
        if (isset($errorMap[$errSeverity])) {
            $errType = $errorMap[$errSeverity];
        }
        
        return $errType;
    }
}


1			<?php
2
3			namespace BFW\Core;
4
5			/**
6			* Class used to have a personnal message/page for errors and exceptions
7			*/
8			class Errors
9			{
10			/**
11			* Constructeur
12			*/
13			public function __construct()
14			{
15			//Find and create the handler for errors
16			$this->defineErrorHandler();
17
18			//Find and create the handler for exceptions
19			$this->defineExceptionHandler();
20			}
21
22			/**
23			* Find and create the handler for errors
24			*
25			* @return void
26			*/
27			protected function defineErrorHandler()
28			{
29			$errorRender = $this->obtainErrorRender();
30
31			//If not render to use
32			if ($errorRender === false) {
33			return;
34			}
35
36			//add the handler for errors
37			set_error_handler([$this, 'errorHandler']);
38			}
39
40			/**
41			* Find and create the handler for exceptions
42			*
43			* @return type
44			*/
45			protected function defineExceptionHandler()
46			{
47			$exceptionRender = $this->obtainExceptionRender();
48
49			//If not render to use
50			if ($exceptionRender === false) {
51			return;
52			}
53
54			//add the handler for exceptions
55			set_exception_handler([$this, 'exceptionHandler']);
56			}
57
58			/**
59			* Get the error render from config for cli or default
60			*
61			* @return boolean\|array Render infos
62			* Boolean : false if no render to use
63			* Array : Infos from config
64			*/
65			protected function obtainErrorRender()
66			{
67			$app = \BFW\Application::getInstance();
68			$renderFcts = $app->getConfig()->getValue('errorRenderFct');
69
70			return $this->defineRenderToUse($renderFcts);
71			}
72
73			/**
74			* Get the exception render from config for cli or default
75			*
76			* @return boolean\|array Render infos
77			* Boolean : false if no render to use
78			* Array : Infos from config
79			*/
80			protected function obtainExceptionRender()
81			{
82			$app = \BFW\Application::getInstance();
83			$renderFcts = $app->getConfig()->getValue('exceptionRenderFct');
84
85			return $this->defineRenderToUse($renderFcts);
86			}
87
88			/**
89			* Find the render to use with the config
90			* If cli render is not define, it's use the default render.
91			*
92			* @param array $renderConfig : Render infos from config
93			*
94			* @return boolean\|array : Render to use
95			* Boolean : false if is no enabled or if no render is defined
96			* Array : The render to use
97			*/
98			protected function defineRenderToUse($renderConfig)
99			{
100			//Check enabled
101			if ($renderConfig['enabled'] === false) {
102			return false;
103			}
104
105			//The cli render if cli mode
106			if (PHP_SAPI === 'cli' && isset($renderConfig['cli'])) {
107			return $renderConfig['cli'];
108			}
109
110			//The default render or cli if cli mode and no cli render configured
111			if (isset($renderConfig['default'])) {
112			return $renderConfig['default'];
113			}
114
115			return false;
116			}
117
118			/**
119			* The default exception handler included in BFW
120			*
121			* @param \Exception $exception : Exception informations
122			*
123			* @return void
124			*/
125			public function exceptionHandler($exception)
126			{
127			$errorRender = $this->obtainExceptionRender();
128
129			$this->callRender(
130			$errorRender,
			0 ignored issues – show Bug introduced 2018-04-06 14:15 UTC by Report Bug Copy Issue Report It seems like `$errorRender` defined by `$this->obtainExceptionRender()` on line `127` can also be of type `boolean`; however, `BFW\Core\Errors::callRender()` does only seem to accept `array`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
131			'Exception Uncaught',
132			$exception->getMessage(),
133			$exception->getFile(),
134			$exception->getLine(),
135			$exception->getTrace()
136			);
137			}
138
139			/**
140			* The default error handler included in BFW
141			*
142			* @param integer $errSeverity : Error severity
143			* @param string $errMsg : Error message
144			* @param string $errFile : File where the error is triggered
145			* @param integer $errLine : Line where the error is triggered
146			*
147			* @return void
148			*/
149			public function errorHandler(
150			$errSeverity,
151			$errMsg,
152			$errFile,
153			$errLine
154			) {
155			$errType = $this->obtainErrorType($errSeverity);
156			$errorRender = $this->obtainErrorRender();
157
158			//Call the "callRender" method for this class (or child class)
159			$this->callRender(
160			$errorRender,
			0 ignored issues – show Bug introduced 2018-04-06 14:15 UTC by Report Bug Copy Issue Report It seems like `$errorRender` defined by `$this->obtainErrorRender()` on line `156` can also be of type `boolean`; however, `BFW\Core\Errors::callRender()` does only seem to accept `array`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
161			$errType,
162			$errMsg,
163			$errFile,
164			$errLine,
165			debug_backtrace()
166			);
167			}
168
169			/**
170			* Call the personnal class-method or function declared on config when
171			* an exception or an error is triggered.
172			*
173			* @param array $renderInfos : Infos from config
174			* @param string $errType : Human readable error severity
175			* @param string $errMsg : Error/exception message
176			* @param string $errFile : File where the error/exception is triggered
177			* @param integer $errLine : Line where the error/exception is triggered
178			* @param array $backtrace : Error/exception backtrace
179			*
180			* @return void
181			*/
182			protected function callRender(
183			$renderInfos,
184			$errType,
185			$errMsg,
186			$errFile,
187			$errLine,
188			$backtrace
189			) {
190			$this->saveIntoPhpLog($errType, $errMsg, $errFile, $errLine);
191
192			$class = $renderInfos['class'];
193			$method = $renderInfos['method'];
194
195			//If is a class, call "$class::$method" (compatibility 5.x)
196			if (!empty($class)) {
197			$class::$method(
198			$errType,
199			$errMsg,
200			$errFile,
201			$errLine,
202			$backtrace
203			);
204
205			return;
206			}
207
208			//If is not a class, it's a function.
209			$method(
210			$errType,
211			$errMsg,
212			$errFile,
213			$errLine,
214			$backtrace
215			);
216			}
217
218			/**
219			* Save the error into the PHP log
220			*
221			* @param string $errType : Human readable error severity
222			* @param string $errMsg : Error/exception message
223			* @param string $errFile : File where the error/exception is triggered
224			* @param integer $errLine : Line where the error/exception is triggered
225			*
226			* @return void
227			*/
228			protected function saveIntoPhpLog(
229			$errType,
230			$errMsg,
231			$errFile,
232			$errLine
233			) {
234			error_log(
235			'Error detected : '.$errType.' '.$errMsg
236			.' at '.$errFile.':'.$errLine
237			);
238			}
239
240			/**
241			* Map array to have a human readable severity.
242			*
243			* @see http://fr2.php.net/manual/fr/function.set-error-handler.php#113567
244			*
245			* @param int $errSeverity : The error severity with PHP constant
246			*
247			* @return string
248			*/
249			protected function obtainErrorType($errSeverity)
250			{
251			$errorMap = [
252			E_ERROR => 'Fatal',
253			E_CORE_ERROR => 'Fatal',
254			E_USER_ERROR => 'Fatal',
255			E_COMPILE_ERROR => 'Fatal',
256			E_RECOVERABLE_ERROR => 'Fatal',
257			E_WARNING => 'Warning',
258			E_CORE_WARNING => 'Warning',
259			E_USER_WARNING => 'Warning',
260			E_COMPILE_WARNING => 'Warning',
261			E_PARSE => 'Parse',
262			E_NOTICE => 'Notice',
263			E_USER_NOTICE => 'Notice',
264			E_STRICT => 'Strict',
265			E_DEPRECATED => 'Deprecated',
266			E_USER_DEPRECATED => 'Deprecated'
267			];
268
269			//Default value if the error is not found in the map array
270			$errType = 'Unknown';
271
272			//Search in map array
273			if (isset($errorMap[$errSeverity])) {
274			$errType = $errorMap[$errSeverity];
275			}
276
277			return $errType;
278			}
279			}
280

bfw-systems / bfw

GitHub Access Token became invalid

Push — 3.0 ( de1771...791612 )

Errors::defaultErrorRender() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like