ErrorHandler::treatExceptions() - Code Metrics - Inspection of "Use `extensions` entry to send not authorized acce..." - overblog/GraphQLBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#37)

by Jérémiah

created 2016-04-25 15:12 UTC

ErrorHandler::treatExceptions() C

↳ Parent: ErrorHandler

Complexity

Conditions	10
Paths	10

Size

Total Lines	63
Code Lines	35

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	37
CRAP Score	10.0929

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	63
ccs	37
cts	41
cp	0.9024
rs	6.3636
cc	10
eloc	35
nc	10
nop	2
crap	10.0929

How to fix Long Method Complexity

<?php

/*
 * This file is part of the OverblogGraphQLBundle package.
 *
 * (c) Overblog <http://github.com/overblog/>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Overblog\GraphQLBundle\Error;

use GraphQL\Error;
use GraphQL\Executor\ExecutionResult;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;

class ErrorHandler
{
    const DEFAULT_ERROR_MESSAGE = 'Internal server Error';

    /** @var LoggerInterface */
    private $logger;

    /** @var string */
    private $internalErrorMessage;

    public function __construct($internalErrorMessage = null, LoggerInterface $logger = null)
    {
        $this->logger = (null === $logger) ? new NullLogger() : $logger;
        if (empty($internalErrorMessage)) {
            $internalErrorMessage = self::DEFAULT_ERROR_MESSAGE;
        }
        $this->internalErrorMessage = $internalErrorMessage;
    }

    /**
     * @param Error[] $errors
     * @param bool    $throwRawException
     *
     * @return array
     *
     * @throws \Exception
     */
    protected function treatExceptions(array $errors, $throwRawException)
    {
        $treatedExceptions = [
            'errors' => [],
            'extensions' => [
                'warnings' => [],
            ],
        ];

        /** @var Error $error */
        foreach ($errors as $error) {
            $rawException = $error->getPrevious();

            // Parse error or user error
            if (null === $rawException) {
                $treatedExceptions['errors'][] = $error;
                continue;
            }

            if ($rawException instanceof UserError) {
                $treatedExceptions['errors'][] = $error;
                if ($rawException->getPrevious()) {
                    $this->logException($rawException->getPrevious());
                }
                continue;
            }

            // user warnings
            if ($rawException instanceof UserWarning) {
                $treatedExceptions['extensions']['warnings'][] = $error;
                if ($rawException->getPrevious()) {
                    $this->logException($rawException->getPrevious());
                }
                continue;
            }

            // multiple errors
            if ($rawException instanceof UserErrors) {
                $rawExceptions = $rawException;
                foreach ($rawExceptions->getErrors() as $rawException) {
                    $treatedExceptions['errors'][] = Error::createLocatedError($rawException, $error->nodes);
                }
                continue;
            }

            // if is a try catch exception wrapped in Error
            if ($throwRawException) {
                throw $rawException;
            }

            $this->logException($rawException);

            $treatedExceptions['errors'][] = new Error(
                $this->internalErrorMessage,
                $error->nodes,
                $rawException,
                $error->getSource(),
                $error->getPositions()
            );
        }

        return $treatedExceptions;
    }

    public function logException(\Exception $exception)
    {
        $message = sprintf(
            '%s: %s[%d] (caught exception) at %s line %s.',
            get_class($exception),
            $exception->getMessage(),
            $exception->getCode(),
            $exception->getFile(),
            $exception->getLine()
        );

        $this->logger->error($message, ['exception' => $exception]);
    }

    public function handleErrors(ExecutionResult $executionResult, $throwRawException = false)
    {
        $exceptions = $this->treatExceptions($executionResult->errors, $throwRawException);
        $executionResult->errors = $exceptions['errors'];
        if (!empty($exceptions['extensions']['warnings'])) {
            $executionResult->extensions['warnings'] = array_map(['GraphQL\Error', 'formatError'], $exceptions['extensions']['warnings']);
        }
    }
}


1		<?php
2
3		/*
4		* This file is part of the OverblogGraphQLBundle package.
5		*
6		* (c) Overblog <http://github.com/overblog/>
7		*
8		* For the full copyright and license information, please view the LICENSE
9		* file that was distributed with this source code.
10		*/
11
12		namespace Overblog\GraphQLBundle\Error;
13
14		use GraphQL\Error;
15		use GraphQL\Executor\ExecutionResult;
16		use Psr\Log\LoggerInterface;
17		use Psr\Log\NullLogger;
18
19		class ErrorHandler
20		{
21		const DEFAULT_ERROR_MESSAGE = 'Internal server Error';
22
23		/** @var LoggerInterface */
24		private $logger;
25
26		/** @var string */
27		private $internalErrorMessage;
28
29	43	public function __construct($internalErrorMessage = null, LoggerInterface $logger = null)
30		{
31	43	$this->logger = (null === $logger) ? new NullLogger() : $logger;
32	43	if (empty($internalErrorMessage)) {
33	43	$internalErrorMessage = self::DEFAULT_ERROR_MESSAGE;
34	43	}
35	43	$this->internalErrorMessage = $internalErrorMessage;
36	43	}
37
38		/**
39		* @param Error[] $errors
40		* @param bool $throwRawException
41		*
42		* @return array
43		*
44		* @throws \Exception
45		*/
46	43	protected function treatExceptions(array $errors, $throwRawException)
47		{
48		$treatedExceptions = [
49	43	'errors' => [],
50		'extensions' => [
51	43	'warnings' => [],
52	43	],
53	43	];
54
55		/** @var Error $error */
56	43	foreach ($errors as $error) {
57	10	$rawException = $error->getPrevious();
58
59		// Parse error or user error
60	10	if (null === $rawException) {
61	4	$treatedExceptions['errors'][] = $error;
62	4	continue;
63	1	}
64
65	7	if ($rawException instanceof UserError) {
66	2	$treatedExceptions['errors'][] = $error;
67	2	if ($rawException->getPrevious()) {
68		$this->logException($rawException->getPrevious());
69		}
70	2	continue;
71		}
72
73		// user warnings
74	6	if ($rawException instanceof UserWarning) {
75	5	$treatedExceptions['extensions']['warnings'][] = $error;
76	5	if ($rawException->getPrevious()) {
77		$this->logException($rawException->getPrevious());
78		}
79	5	continue;
80		}
81
82		// multiple errors
83	2	if ($rawException instanceof UserErrors) {
84	1	$rawExceptions = $rawException;
85	1	foreach ($rawExceptions->getErrors() as $rawException) {
86	1	$treatedExceptions['errors'][] = Error::createLocatedError($rawException, $error->nodes);
87	1	}
88	1	continue;
89		}
90
91		// if is a try catch exception wrapped in Error
92	2	if ($throwRawException) {
93	1	throw $rawException;
94		}
95
96	1	$this->logException($rawException);
97
98	1	$treatedExceptions['errors'][] = new Error(
99	1	$this->internalErrorMessage,
100	1	$error->nodes,
101	1	$rawException,
102	1	$error->getSource(),
103	1	$error->getPositions()
104	1	);
105	42	}
106
107	42	return $treatedExceptions;
108		}
109
110	1	public function logException(\Exception $exception)
111		{
112	1	$message = sprintf(
113	1	'%s: %s[%d] (caught exception) at %s line %s.',
114	1	get_class($exception),
115	1	$exception->getMessage(),
116	1	$exception->getCode(),
117	1	$exception->getFile(),
118	1	$exception->getLine()
119	1	);
120
121	1	$this->logger->error($message, ['exception' => $exception]);
122	1	}
123
124	43	public function handleErrors(ExecutionResult $executionResult, $throwRawException = false)
125		{
126	43	$exceptions = $this->treatExceptions($executionResult->errors, $throwRawException);
127	42	$executionResult->errors = $exceptions['errors'];
128	42	if (!empty($exceptions['extensions']['warnings'])) {
129	5	$executionResult->extensions['warnings'] = array_map(['GraphQL\Error', 'formatError'], $exceptions['extensions']['warnings']);
130	5	}
131	42	}
132		}
133

overblog / GraphQLBundle

Scrutinizer GitHub App not installed

Pull Request — master (#37)

ErrorHandler::treatExceptions() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like