ErrorHandler::treatExceptions() - Code Metrics - Inspection of "add inheritance exception mapping option" - overblog/GraphQLBundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#236)

by Herberto

created 2017-11-07 20:37 UTC

ErrorHandler::treatExceptions() C

↳ Parent: ErrorHandler

Complexity

Conditions	11
Paths	10

Size

Total Lines	65
Code Lines	36

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	33
CRAP Score	11

Importance

Changes

Metric	Value
dl	0
loc	65
ccs	33
cts	33
cp	1
rs	5.9999
c	0
b	0
f	0
cc	11
eloc	36
nc	10
nop	2
crap	11

How to fix Long Method Complexity

<?php

namespace Overblog\GraphQLBundle\Error;

use GraphQL\Error\Error as GraphQLError;
use GraphQL\Error\UserError as GraphQLUserError;
use GraphQL\Executor\ExecutionResult;
use Psr\Log\LoggerInterface;
use Psr\Log\LogLevel;
use Psr\Log\NullLogger;

class ErrorHandler
{
    const DEFAULT_ERROR_MESSAGE = 'Internal server Error';
    const DEFAULT_USER_WARNING_CLASS = UserWarning::class;
    const DEFAULT_USER_ERROR_CLASS = UserError::class;

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

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

    /** @var array */
    private $exceptionMap;

    /** @var string */
    private $userWarningClass = self::DEFAULT_USER_WARNING_CLASS;

    /** @var string */
    private $userErrorClass = self::DEFAULT_USER_ERROR_CLASS;

    /** @var bool */
    private $mapExceptionsToParent;

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

    public function setUserWarningClass($userWarningClass)
    {
        $this->userWarningClass = $userWarningClass;

        return $this;
    }

    public function setUserErrorClass($userErrorClass)
    {
        $this->userErrorClass = $userErrorClass;

        return $this;
    }

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

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

            // raw GraphQL Error or InvariantViolation exception
            if (null === $rawException || $rawException instanceof GraphQLUserError) {
                $treatedExceptions['errors'][] = $error;
                continue;
            }

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

            // user warning
            if ($rawException instanceof $this->userWarningClass) {
                $treatedExceptions['extensions']['warnings'][] = $error;
                if ($rawException->getPrevious()) {
                    $this->logException($rawException->getPrevious(), LogLevel::WARNING);
                }
                continue;
            }

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

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

            $this->logException($rawException, LogLevel::CRITICAL);

            $treatedExceptions['errors'][] = new GraphQLError(
                $this->internalErrorMessage,
                $error->nodes,
                $error->getSource(),
                $error->getPositions(),
                $error->path,
                $rawException
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            );
        }

        return $treatedExceptions;
    }

    /**
     * @param \Exception|\Error $exception
     * @param string            $errorLevel
     */
    public function logException($exception, $errorLevel = LogLevel::ERROR)
    {
        $message = sprintf(
            '%s: %s[%d] (caught exception) at %s line %s.',
            get_class($exception),
            $exception->getMessage(),
            $exception->getCode(),
            $exception->getFile(),
            $exception->getLine()
        );

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

    public function handleErrors(ExecutionResult $executionResult, $throwRawException = false)
    {
        $executionResult->setErrorFormatter(sprintf('\%s::formatError', GraphQLError::class));
        $exceptions = $this->treatExceptions($executionResult->errors, $throwRawException);
        $executionResult->errors = $exceptions['errors'];
        if (!empty($exceptions['extensions']['warnings'])) {
            $executionResult->extensions['warnings'] = array_map([GraphQLError::class, 'formatError'], $exceptions['extensions']['warnings']);
        }
    }

    /**
     * Tries to convert a raw exception into a user warning or error
     * that is displayed to the user.
     *
     * @param \Exception|\Error $rawException
     *
     * @return \Exception|\Error
     */
    protected function convertException($rawException = null)
    {
        if (null === $rawException) {
            return;
        }

        $errorClass = $this->findErrorClass($rawException);
        if (null !== $errorClass) {
            return new $errorClass($rawException->getMessage(), $rawException->getCode(), $rawException);
        }

        return $rawException;
    }

    /**
     * @param \Exception|\Error $rawException
     *
     * @return string|null
     */
    private function findErrorClass($rawException)
    {
        $rawExceptionClass = get_class($rawException);
        if (isset($this->exceptionMap[$rawExceptionClass])) {
            return $this->exceptionMap[$rawExceptionClass];
        }

        if ($this->mapExceptionsToParent) {
            return $this->findErrorClassUsingParentException($rawException);
        }

        return null;
    }

    /**
     * @param \Exception|\Error $rawException
     *
     * @return string|null
     */
    private function findErrorClassUsingParentException($rawException)
    {
        foreach ($this->exceptionMap as $rawExceptionClass => $errorClass) {
            if ($rawException instanceof $rawExceptionClass) {
                return $errorClass;
            }
        }

        return null;
    }
}


1		<?php
2
3		namespace Overblog\GraphQLBundle\Error;
4
5		use GraphQL\Error\Error as GraphQLError;
6		use GraphQL\Error\UserError as GraphQLUserError;
7		use GraphQL\Executor\ExecutionResult;
8		use Psr\Log\LoggerInterface;
9		use Psr\Log\LogLevel;
10		use Psr\Log\NullLogger;
11
12		class ErrorHandler
13		{
14		const DEFAULT_ERROR_MESSAGE = 'Internal server Error';
15		const DEFAULT_USER_WARNING_CLASS = UserWarning::class;
16		const DEFAULT_USER_ERROR_CLASS = UserError::class;
17
18		/** @var LoggerInterface */
19		private $logger;
20
21		/** @var string */
22		private $internalErrorMessage;
23
24		/** @var array */
25		private $exceptionMap;
26
27		/** @var string */
28		private $userWarningClass = self::DEFAULT_USER_WARNING_CLASS;
29
30		/** @var string */
31		private $userErrorClass = self::DEFAULT_USER_ERROR_CLASS;
32
33		/** @var bool */
34		private $mapExceptionsToParent;
35
36	83	public function __construct(
37		$internalErrorMessage = null,
38		LoggerInterface $logger = null,
39		array $exceptionMap = [],
40		$mapExceptionsToParent = false
41		) {
42	83	$this->logger = (null === $logger) ? new NullLogger() : $logger;
43	83	if (empty($internalErrorMessage)) {
44	76	$internalErrorMessage = self::DEFAULT_ERROR_MESSAGE;
45		}
46	83	$this->internalErrorMessage = $internalErrorMessage;
47	83	$this->exceptionMap = $exceptionMap;
48	83	$this->mapExceptionsToParent = $mapExceptionsToParent;
49	83	}
50
51	71	public function setUserWarningClass($userWarningClass)
52		{
53	71	$this->userWarningClass = $userWarningClass;
54
55	71	return $this;
56		}
57
58	71	public function setUserErrorClass($userErrorClass)
59		{
60	71	$this->userErrorClass = $userErrorClass;
61
62	71	return $this;
63		}
64
65		/**
66		* @param GraphQLError[] $errors
67		* @param bool $throwRawException
68		*
69		* @return array
70		*
71		* @throws \Exception
72		*/
73	69	protected function treatExceptions(array $errors, $throwRawException)
74		{
75		$treatedExceptions = [
76	69	'errors' => [],
77		'extensions' => [
78		'warnings' => [],
79		],
80		];
81
82		/** @var GraphQLError $error */
83	69	foreach ($errors as $error) {
84	24	$rawException = $this->convertException($error->getPrevious());
85
86		// raw GraphQL Error or InvariantViolation exception
87	24	if (null === $rawException \|\| $rawException instanceof GraphQLUserError) {
88	9	$treatedExceptions['errors'][] = $error;
89	9	continue;
90		}
91
92		// user error
93	16	if ($rawException instanceof $this->userErrorClass) {
94	8	$treatedExceptions['errors'][] = $error;
95	8	if ($rawException->getPrevious()) {
96	5	$this->logException($rawException->getPrevious());
97		}
98	8	continue;
99		}
100
101		// user warning
102	9	if ($rawException instanceof $this->userWarningClass) {
103	7	$treatedExceptions['extensions']['warnings'][] = $error;
104	7	if ($rawException->getPrevious()) {
105	3	$this->logException($rawException->getPrevious(), LogLevel::WARNING);
106		}
107	7	continue;
108		}
109
110		// multiple errors
111	3	if ($rawException instanceof UserErrors) {
112	1	$rawExceptions = $rawException;
113	1	foreach ($rawExceptions->getErrors() as $rawException) {
114	1	$treatedExceptions['errors'][] = GraphQLError::createLocatedError($rawException, $error->nodes);
115		}
116	1	continue;
117		}
118
119		// if is a try catch exception wrapped in Error
120	3	if ($throwRawException) {
121	2	throw $rawException;
122		}
123
124	1	$this->logException($rawException, LogLevel::CRITICAL);
125
126	1	$treatedExceptions['errors'][] = new GraphQLError(
127	1	$this->internalErrorMessage,
128	1	$error->nodes,
129	1	$error->getSource(),
130	1	$error->getPositions(),
131	1	$error->path,
132	1	$rawException
		0 ignored issues – show Documentation introduced 2017-08-29 09:19 UTC by Report Bug Copy Issue Report `$rawException` is of type `object<Exception>`, but the function expects a `object<Throwable>\|null`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
133		);
134		}
135
136	67	return $treatedExceptions;
137		}
138
139		/**
140		* @param \Exception\|\Error $exception
141		* @param string $errorLevel
142		*/
143	9	public function logException($exception, $errorLevel = LogLevel::ERROR)
144		{
145	9	$message = sprintf(
146	9	'%s: %s[%d] (caught exception) at %s line %s.',
147	9	get_class($exception),
148	9	$exception->getMessage(),
149	9	$exception->getCode(),
150	9	$exception->getFile(),
151	9	$exception->getLine()
152		);
153
154	9	$this->logger->$errorLevel($message, ['exception' => $exception]);
155	9	}
156
157	69	public function handleErrors(ExecutionResult $executionResult, $throwRawException = false)
158		{
159	69	$executionResult->setErrorFormatter(sprintf('\%s::formatError', GraphQLError::class));
160	69	$exceptions = $this->treatExceptions($executionResult->errors, $throwRawException);
161	67	$executionResult->errors = $exceptions['errors'];
162	67	if (!empty($exceptions['extensions']['warnings'])) {
163	7	$executionResult->extensions['warnings'] = array_map([GraphQLError::class, 'formatError'], $exceptions['extensions']['warnings']);
164		}
165	67	}
166
167		/**
168		* Tries to convert a raw exception into a user warning or error
169		* that is displayed to the user.
170		*
171		* @param \Exception\|\Error $rawException
172		*
173		* @return \Exception\|\Error
174		*/
175	24	protected function convertException($rawException = null)
176		{
177	24	if (null === $rawException) {
178	9	return;
179		}
180
181	16	$errorClass = $this->findErrorClass($rawException);
182	16	if (null !== $errorClass) {
183	8	return new $errorClass($rawException->getMessage(), $rawException->getCode(), $rawException);
184		}
185
186	8	return $rawException;
187		}
188
189		/**
190		* @param \Exception\|\Error $rawException
191		*
192		* @return string\|null
193		*/
194	16	private function findErrorClass($rawException)
195		{
196	16	$rawExceptionClass = get_class($rawException);
197	16	if (isset($this->exceptionMap[$rawExceptionClass])) {
198	7	return $this->exceptionMap[$rawExceptionClass];
199		}
200
201	9	if ($this->mapExceptionsToParent) {
202	1	return $this->findErrorClassUsingParentException($rawException);
203		}
204
205	8	return null;
206		}
207
208		/**
209		* @param \Exception\|\Error $rawException
210		*
211		* @return string\|null
212		*/
213	1	private function findErrorClassUsingParentException($rawException)
214		{
215	1	foreach ($this->exceptionMap as $rawExceptionClass => $errorClass) {
216	1	if ($rawException instanceof $rawExceptionClass) {
217	1	return $errorClass;
218		}
219		}
220
221		return null;
222		}
223		}
224

overblog / GraphQLBundle

Scrutinizer GitHub App not installed

Pull Request — master (#236)

ErrorHandler::treatExceptions() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like