ErrorHandler::treatExceptions() - Code Metrics - Inspection of "Exceptions can be mapped to UserError and UserWarn..." - overblog/GraphQLBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#64)

by Adrian

created 2016-09-21 10:48 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	40
CRAP Score	10

Importance

Changes

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

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;

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

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

    /**
     * @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 = $this->convertException($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']);
        }
    }

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

        if (!empty($this->exceptionMap[get_class($rawException)])) {
            $errorClass = $this->exceptionMap[get_class($rawException)];

            return new $errorClass($rawException->getMessage(), $rawException->getCode(), $rawException);
        }

        return $rawException;
    }
}


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		/** @var array */
30		private $exceptionMap;
31
32	13	public function __construct($internalErrorMessage = null, LoggerInterface $logger = null, array $exceptionMap = [])
33		{
34	13	$this->logger = (null === $logger) ? new NullLogger() : $logger;
35	13	if (empty($internalErrorMessage)) {
36	12	$internalErrorMessage = self::DEFAULT_ERROR_MESSAGE;
37	12	}
38	13	$this->internalErrorMessage = $internalErrorMessage;
39	13	$this->exceptionMap = $exceptionMap;
40	13	}
41
42		/**
43		* @param Error[] $errors
44		* @param bool $throwRawException
45		*
46		* @return array
47		*
48		* @throws \Exception
49		*/
50	45	protected function treatExceptions(array $errors, $throwRawException)
51		{
52		$treatedExceptions = [
53	45	'errors' => [],
54		'extensions' => [
55	45	'warnings' => [],
56	45	],
57	45	];
58
59		/** @var Error $error */
60	45	foreach ($errors as $error) {
61	12	$rawException = $this->convertException($error->getPrevious());
62
63		// Parse error or user error
64	12	if (null === $rawException) {
65	4	$treatedExceptions['errors'][] = $error;
66	4	continue;
67		}
68
69	9	if ($rawException instanceof UserError) {
70	4	$treatedExceptions['errors'][] = $error;
71	4	if ($rawException->getPrevious()) {
72	1	$this->logException($rawException->getPrevious());
73	1	}
74	4	continue;
75		}
76
77		// user warnings
78	6	if ($rawException instanceof UserWarning) {
79	5	$treatedExceptions['extensions']['warnings'][] = $error;
80	5	if ($rawException->getPrevious()) {
81	1	$this->logException($rawException->getPrevious());
82	1	}
83	5	continue;
84		}
85
86		// multiple errors
87	2	if ($rawException instanceof UserErrors) {
88	1	$rawExceptions = $rawException;
89	1	foreach ($rawExceptions->getErrors() as $rawException) {
90	1	$treatedExceptions['errors'][] = Error::createLocatedError($rawException, $error->nodes);
91	1	}
92	1	continue;
93		}
94
95		// if is a try catch exception wrapped in Error
96	2	if ($throwRawException) {
97	1	throw $rawException;
98		}
99
100	1	$this->logException($rawException);
101
102	1	$treatedExceptions['errors'][] = new Error(
103	1	$this->internalErrorMessage,
104	1	$error->nodes,
105	1	$rawException,
106	1	$error->getSource(),
107	1	$error->getPositions()
108	1	);
109	44	}
110
111	44	return $treatedExceptions;
112		}
113
114	3	public function logException(\Exception $exception)
115		{
116	3	$message = sprintf(
117	3	'%s: %s[%d] (caught exception) at %s line %s.',
118	3	get_class($exception),
119	3	$exception->getMessage(),
120	3	$exception->getCode(),
121	3	$exception->getFile(),
122	3	$exception->getLine()
123	3	);
124
125	3	$this->logger->error($message, ['exception' => $exception]);
126	3	}
127
128	45	public function handleErrors(ExecutionResult $executionResult, $throwRawException = false)
129		{
130	45	$exceptions = $this->treatExceptions($executionResult->errors, $throwRawException);
131	44	$executionResult->errors = $exceptions['errors'];
132	44	if (!empty($exceptions['extensions']['warnings'])) {
133	5	$executionResult->extensions['warnings'] = array_map(['GraphQL\Error', 'formatError'], $exceptions['extensions']['warnings']);
134	5	}
135	44	}
136
137		/**
138		* Tries to convert a raw exception into a user warning or error
139		* that is displayed to the user.
140		*
141		* @param \Exception $rawException
142		* @return \Exception
143		*/
144	12	protected function convertException(\Exception $rawException = null)
145		{
146	12	if (null === $rawException) {
147	4	return null;
148		}
149
150	9	if (!empty($this->exceptionMap[get_class($rawException)])) {
151	2	$errorClass = $this->exceptionMap[get_class($rawException)];
152
153	2	return new $errorClass($rawException->getMessage(), $rawException->getCode(), $rawException);
154		}
155
156	7	return $rawException;
157		}
158		}
159

overblog / GraphQLBundle

Scrutinizer GitHub App not installed

Pull Request — master (#64)

ErrorHandler::treatExceptions() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like