NestedValidationException::getRelatedByName() - Code Metrics - Inspection of "Improve RuleTestCase class" - Respect/Validation - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 2d7e2e...fe3654 )

by Henrique

created 2018-01-07 13:49 UTC

NestedValidationException::getRelatedByName() A

↳ Parent: NestedValidationException

Complexity

Conditions	4
Paths	4

Size

Total Lines	12
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	4

Importance

Changes

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

<?php

/*
 * This file is part of Respect/Validation.
 *
 * (c) Alexandre Gomes Gaigalas <[email protected]>
 *
 * For the full copyright and license information, please view the "LICENSE.md"
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Respect\Validation\Exceptions;

use IteratorAggregate;
use RecursiveIteratorIterator;
use SplObjectStorage;

class NestedValidationException extends ValidationException implements IteratorAggregate
{
    /**
     * @var SplObjectStorage
     */
    private $exceptions = [];

    /**
     * @param ValidationException $exception
     *
     * @return self
     */
    public function addRelated(ValidationException $exception)
    {
        $this->getRelated()->attach($exception);

        return $this;
    }

    /**
     * @param string              $path
     * @param ValidationException $exception
     *
     * @return ValidationException
     */
    private function getExceptionForPath($path, ValidationException $exception)
    {
        if ($path === $exception->guessId()) {
            return $exception;
        }

        if (!$exception instanceof self) {
            return $exception;
        }

        foreach ($exception as $subException) {
            return $subException;
        }

        return $exception;
    }

    /**
     * @param array $paths
     *
     * @return string[]
     */
    public function findMessages(array $paths)
    {
        $messages = [];

        foreach ($paths as $key => $value) {
            $numericKey = is_numeric($key);
            $path = $numericKey ? $value : $key;

            if (!($exception = $this->getRelatedByName($path))) {
                $exception = $this->findRelated($path);
            }

            $path = str_replace('.', '_', $path);

            if (!$exception) {
                $messages[$path] = '';
                continue;
            }

            $exception = $this->getExceptionForPath($path, $exception);
            if (!$numericKey) {
                $exception->setTemplate($value);
            }

            $messages[$path] = $exception->getMainMessage();
        }

        return $messages;
    }

    /**
     * @return Exception
     */
    public function findRelated($path)
    {
        $target = $this;
        $pieces = explode('.', $path);

        while (!empty($pieces) && $target) {
            $piece = array_shift($pieces);
            $target = $target->getRelatedByName($piece);
        }

        return $target;
    }

    /**
     * @return RecursiveIteratorIterator
     */
    private function getRecursiveIterator()
    {
        $exceptionIterator = new RecursiveExceptionIterator($this);
        $recursiveIteratorIterator = new RecursiveIteratorIterator(
            $exceptionIterator,
            RecursiveIteratorIterator::SELF_FIRST
        );

        return $recursiveIteratorIterator;
    }

    /**
     * Returns weather an exception should be omitted or not.
     *
     * @param ExceptionInterface $exception
     *
     * @return bool
     */
    private function isOmissible(ExceptionInterface $exception)
    {
        if (!$exception instanceof self) {
            return false;
        }

        $relatedExceptions = $exception->getRelated();
        $relatedExceptions->rewind();
        $childException = $relatedExceptions->current();

        return 1 === $relatedExceptions->count() && !$childException instanceof NonOmissibleExceptionInterface;
    }

    /**
     * @return SplObjectStorage
     */
    public function getIterator()
    {
        $childrenExceptions = new SplObjectStorage();

        $recursiveIteratorIterator = $this->getRecursiveIterator();
        $exceptionIterator = $recursiveIteratorIterator->getInnerIterator();

        $lastDepth = 0;
        $lastDepthOriginal = 0;
        $knownDepths = [];
        foreach ($recursiveIteratorIterator as $childException) {
            if ($this->isOmissible($childException)) {
                continue;
            }

            $currentDepth = $lastDepth;
            $currentDepthOriginal = $recursiveIteratorIterator->getDepth() + 1;

            if (isset($knownDepths[$currentDepthOriginal])) {
                $currentDepth = $knownDepths[$currentDepthOriginal];
            } elseif ($currentDepthOriginal > $lastDepthOriginal
                && ($this->hasCustomTemplate() || 1 != $exceptionIterator->count())) {
                ++$currentDepth;
            }

            if (!isset($knownDepths[$currentDepthOriginal])) {
                $knownDepths[$currentDepthOriginal] = $currentDepth;
            }

            $lastDepth = $currentDepth;
            $lastDepthOriginal = $currentDepthOriginal;

            $childrenExceptions->attach(
                $childException,
                [
                    'depth' => $currentDepth,
                    'depth_original' => $currentDepthOriginal,
                    'previous_depth' => $lastDepth,
                    'previous_depth_original' => $lastDepthOriginal,
                ]
            );
        }

        return $childrenExceptions;
    }

    /**
     * @return array
     */
    public function getMessages()
    {
        $messages = [$this->getMessage()];
        foreach ($this as $exception) {
            $messages[] = $exception->getMessage();
        }

        if (count($messages) > 1) {
            array_shift($messages);
        }

        return $messages;
    }

    /**
     * @return string
     */
    public function getFullMessage()
    {
        $marker = '-';
        $messages = [];
        $exceptions = $this->getIterator();

        if ($this->hasCustomTemplate() || 1 != count($exceptions)) {
            $messages[] = sprintf('%s %s', $marker, $this->getMessage());
        }

        foreach ($exceptions as $exception) {
            $depth = $exceptions[$exception]['depth'];
            $prefix = str_repeat(' ', $depth * 2);
            $messages[] = sprintf('%s%s %s', $prefix, $marker, $exception->getMessage());
        }

        return implode(PHP_EOL, $messages);
    }

    /**
     * @return SplObjectStorage
     */
    public function getRelated()
    {
        if (!$this->exceptions instanceof SplObjectStorage) {
            $this->exceptions = new SplObjectStorage();
        }

        return $this->exceptions;
    }

    /**
     * @param string $name
     * @param mixed  $value
     *
     * @return self
     */
    public function setParam($name, $value)
    {
        if ('translator' === $name) {
            foreach ($this->getRelated() as $exception) {
                $exception->setParam($name, $value);
            }
        }

        parent::setParam($name, $value);

        return $this;
    }

    /**
     * @return bool
     */
    private function isRelated($name, ValidationException $exception)
    {
        return $exception->getId() === $name || $exception->getName() === $name;
    }

    /**
     * @return ValidationException
     */
    public function getRelatedByName($name)
    {
        if ($this->isRelated($name, $this)) {
            return $this;
        }

        foreach ($this->getRecursiveIterator() as $exception) {
            if ($this->isRelated($name, $exception)) {
                return $exception;
            }
        }
    }

    /**
     * @param array $exceptions
     *
     * @return self
     */
    public function setRelated(array $exceptions)
    {
        foreach ($exceptions as $exception) {
            $this->addRelated($exception);
        }

        return $this;
    }
}


1		<?php
2
3		/*
4		* This file is part of Respect/Validation.
5		*
6		* (c) Alexandre Gomes Gaigalas <[email protected]>
7		*
8		* For the full copyright and license information, please view the "LICENSE.md"
9		* file that was distributed with this source code.
10		*/
11
12		declare(strict_types=1);
13
14		namespace Respect\Validation\Exceptions;
15
16		use IteratorAggregate;
17		use RecursiveIteratorIterator;
18		use SplObjectStorage;
19
20		class NestedValidationException extends ValidationException implements IteratorAggregate
21		{
22		/**
23		* @var SplObjectStorage
24		*/
25		private $exceptions = [];
26
27		/**
28		* @param ValidationException $exception
29		*
30		* @return self
31		*/
32	127	public function addRelated(ValidationException $exception)
33		{
34	127	$this->getRelated()->attach($exception);
35
36	127	return $this;
37		}
38
39		/**
40		* @param string $path
41		* @param ValidationException $exception
42		*
43		* @return ValidationException
44		*/
45	8	private function getExceptionForPath($path, ValidationException $exception)
46		{
47	8	if ($path === $exception->guessId()) {
48	5	return $exception;
49		}
50
51	6	if (!$exception instanceof self) {
52	2	return $exception;
53		}
54
55	4	foreach ($exception as $subException) {
56	4	return $subException;
57		}
58
59	1	return $exception;
60		}
61
62		/**
63		* @param array $paths
64		*
65		* @return string[]
66		*/
67	8	public function findMessages(array $paths)
68		{
69	8	$messages = [];
70
71	8	foreach ($paths as $key => $value) {
72	8	$numericKey = is_numeric($key);
73	8	$path = $numericKey ? $value : $key;
74
75	8	if (!($exception = $this->getRelatedByName($path))) {
76	4	$exception = $this->findRelated($path);
77		}
78
79	8	$path = str_replace('.', '_', $path);
80
81	8	if (!$exception) {
82	1	$messages[$path] = '';
83	1	continue;
84		}
85
86	8	$exception = $this->getExceptionForPath($path, $exception);
87	8	if (!$numericKey) {
88	4	$exception->setTemplate($value);
89		}
90
91	8	$messages[$path] = $exception->getMainMessage();
92		}
93
94	8	return $messages;
95		}
96
97		/**
98		* @return Exception
99		*/
100	5	public function findRelated($path)
101		{
102	5	$target = $this;
103	5	$pieces = explode('.', $path);
104
105	5	while (!empty($pieces) && $target) {
106	5	$piece = array_shift($pieces);
107	5	$target = $target->getRelatedByName($piece);
108		}
109
110	5	return $target;
111		}
112
113		/**
114		* @return RecursiveIteratorIterator
115		*/
116	122	private function getRecursiveIterator()
117		{
118	122	$exceptionIterator = new RecursiveExceptionIterator($this);
119	122	$recursiveIteratorIterator = new RecursiveIteratorIterator(
120	122	$exceptionIterator,
121	122	RecursiveIteratorIterator::SELF_FIRST
122		);
123
124	122	return $recursiveIteratorIterator;
125		}
126
127		/**
128		* Returns weather an exception should be omitted or not.
129		*
130		* @param ExceptionInterface $exception
131		*
132		* @return bool
133		*/
134	116	private function isOmissible(ExceptionInterface $exception)
135		{
136	116	if (!$exception instanceof self) {
137	114	return false;
138		}
139
140	17	$relatedExceptions = $exception->getRelated();
141	17	$relatedExceptions->rewind();
142	17	$childException = $relatedExceptions->current();
143
144	17	return 1 === $relatedExceptions->count() && !$childException instanceof NonOmissibleExceptionInterface;
145		}
146
147		/**
148		* @return SplObjectStorage
149		*/
150	117	public function getIterator()
151		{
152	117	$childrenExceptions = new SplObjectStorage();
153
154	117	$recursiveIteratorIterator = $this->getRecursiveIterator();
155	117	$exceptionIterator = $recursiveIteratorIterator->getInnerIterator();
156
157	117	$lastDepth = 0;
158	117	$lastDepthOriginal = 0;
159	117	$knownDepths = [];
160	117	foreach ($recursiveIteratorIterator as $childException) {
161	116	if ($this->isOmissible($childException)) {
162	15	continue;
163		}
164
165	116	$currentDepth = $lastDepth;
166	116	$currentDepthOriginal = $recursiveIteratorIterator->getDepth() + 1;
167
168	116	if (isset($knownDepths[$currentDepthOriginal])) {
169	13	$currentDepth = $knownDepths[$currentDepthOriginal];
170	116	} elseif ($currentDepthOriginal > $lastDepthOriginal
171	116	&& ($this->hasCustomTemplate() \|\| 1 != $exceptionIterator->count())) {
172	13	++$currentDepth;
173		}
174
175	116	if (!isset($knownDepths[$currentDepthOriginal])) {
176	116	$knownDepths[$currentDepthOriginal] = $currentDepth;
177		}
178
179	116	$lastDepth = $currentDepth;
180	116	$lastDepthOriginal = $currentDepthOriginal;
181
182	116	$childrenExceptions->attach(
183	116	$childException,
184		[
185	116	'depth' => $currentDepth,
186	116	'depth_original' => $currentDepthOriginal,
187	116	'previous_depth' => $lastDepth,
188	116	'previous_depth_original' => $lastDepthOriginal,
189		]
190		);
191		}
192
193	117	return $childrenExceptions;
194		}
195
196		/**
197		* @return array
198		*/
199	4	public function getMessages()
200		{
201	4	$messages = [$this->getMessage()];
202	4	foreach ($this as $exception) {
203	4	$messages[] = $exception->getMessage();
204		}
205
206	4	if (count($messages) > 1) {
207	4	array_shift($messages);
208		}
209
210	4	return $messages;
211		}
212
213		/**
214		* @return string
215		*/
216	110	public function getFullMessage()
217		{
218	110	$marker = '-';
219	110	$messages = [];
220	110	$exceptions = $this->getIterator();
221
222	110	if ($this->hasCustomTemplate() \|\| 1 != count($exceptions)) {
223	11	$messages[] = sprintf('%s %s', $marker, $this->getMessage());
224		}
225
226	110	foreach ($exceptions as $exception) {
227	109	$depth = $exceptions[$exception]['depth'];
228	109	$prefix = str_repeat(' ', $depth * 2);
229	109	$messages[] = sprintf('%s%s %s', $prefix, $marker, $exception->getMessage());
230		}
231
232	110	return implode(PHP_EOL, $messages);
233		}
234
235		/**
236		* @return SplObjectStorage
237		*/
238	128	public function getRelated()
239		{
240	128	if (!$this->exceptions instanceof SplObjectStorage) {
241	128	$this->exceptions = new SplObjectStorage();
242		}
243
244	128	return $this->exceptions;
245		}
246
247		/**
248		* @param string $name
249		* @param mixed $value
250		*
251		* @return self
252		*/
253	1	public function setParam($name, $value)
254		{
255	1	if ('translator' === $name) {
256	1	foreach ($this->getRelated() as $exception) {
257	1	$exception->setParam($name, $value);
258		}
259		}
260
261	1	parent::setParam($name, $value);
262
263	1	return $this;
264		}
265
266		/**
267		* @return bool
268		*/
269	9	private function isRelated($name, ValidationException $exception)
270		{
271	9	return $exception->getId() === $name \|\| $exception->getName() === $name;
272		}
273
274		/**
275		* @return ValidationException
276		*/
277	9	public function getRelatedByName($name)
278		{
279	9	if ($this->isRelated($name, $this)) {
280	2	return $this;
281		}
282
283	9	foreach ($this->getRecursiveIterator() as $exception) {
284	9	if ($this->isRelated($name, $exception)) {
285	9	return $exception;
286		}
287		}
288	5	}
289
290		/**
291		* @param array $exceptions
292		*
293		* @return self
294		*/
295	124	public function setRelated(array $exceptions)
296		{
297	124	foreach ($exceptions as $exception) {
298	124	$this->addRelated($exception);
299		}
300
301	124	return $this;
302		}
303		}
304

Respect / Validation

Scrutinizer GitHub App not installed

Push — master ( 2d7e2e...fe3654 )

NestedValidationException::getRelatedByName() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like