Evacuator::__construct() - Code Metrics - SerafimArts/Evacuator - Measure and Improve Code Quality continuously with Scrutinizer

Evacuator::__construct() A
last analyzed 2016-12-29 19:11 UTC

↳ Parent: Evacuator

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	2
nc	1
nop	1
dl	0
loc	4
rs	10
c	0
b	0
f	0

<?php declare(strict_types = 1);
/**
 * This file is part of Evacuator package.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace Serafim\Evacuator;

/**
 * Class Evacuator
 * @package Serafim\Evacuator
 */
class Evacuator
{
    /**
     * @var string
     * @internal
     */
    const CATCH_ALL_EXCEPTIONS = '*';

    /**
     * @var int
     */
    const INFINITY_RETRIES = -100;

    /**
     * @var \Closure
     */
    private $context;

    /**
     * @var int
     */
    private $retries = 0;

    /**
     * @var array|\Closure[]
     */
    private $catches = [];

    /**
     * @var null|\Closure
     */
    private $then;

    /**
     * @var array|\Closure
     */
    private $everyError = [];

    /**
     * Evacuator constructor.
     * @param \Closure $context
     */
    public function __construct(\Closure $context)
    {
        $this->context = $context;
    }

    /**
     * @param array ...$args
     * @return mixed
     * @throws \Throwable
     */
    public function __invoke(...$args)
    {
        return $this->invoke(...$args);
    }

    /**
     * @param int $count
     * @return Evacuator
     * @throws \InvalidArgumentException
     */
    public function retries(int $count): Evacuator
    {
        if ($count < 0 && $count !== static::INFINITY_RETRIES) {
            throw new \InvalidArgumentException('Retries count must be greater than 0');
        }

        $this->retries = $count;

        return $this;
    }

    /**
     * @param \Closure $then
     * @return Evacuator|$this
     * @throws \InvalidArgumentException
     */
    public function catch(\Closure $then): Evacuator

    {
        $exceptionClass = $this->resolveTypeHint($then, \Throwable::class);

        $this->catches[$exceptionClass] = $then;
class A {
    var $property;
}

        return $this;
class A {
    var $property;
}
    }

    /**
     * @param \Closure $then
     * @return Evacuator
     * @throws \InvalidArgumentException
     */
    public function onError(\Closure $then): Evacuator

    {
        $exceptionClass = $this->resolveTypeHint($then, \Throwable::class);

        $this->everyError[$exceptionClass] = $then;

        return $this;
    }

    /**
     * @param \Closure $closure
     * @param string $instanceOf
     * @return string
     * @throws \InvalidArgumentException
     */
    private function resolveTypeHint(\Closure $closure, string $instanceOf): string
    {
        $parameters = (new \ReflectionFunction($closure))->getParameters();

        // Callback has ony one argument
        if (1 !== count($parameters)) {
            throw new \InvalidArgumentException(
                'Closure argument of catch(...) method required ' . (count($parameters) > 1 ? 'only ' :'') .
                '1 parameter ' . count($parameters) . ' given'
            );
        }

        // Callback has no type hints
        if (null === reset($parameters)->getType()) {
            return static::CATCH_ALL_EXCEPTIONS;
        }

        $typeHintClass = reset($parameters)->getClass();

        // Callback has primitive type hint
        if (null === $typeHintClass) {
            throw new \InvalidArgumentException(
                'Closure argument of catch(...) method type hint can not be a primitive'
            );
        }

        if (!($typeHintClass->newInstanceWithoutConstructor() instanceof $instanceOf)) {
            throw new \InvalidArgumentException(
                'Closure argument of catch(...) method type hint must be instance of ' . $instanceOf .
                    ', ' . $typeHintClass->name . ' given'
            );
        }

        return $typeHintClass->name;
    }

    /**
     * @param array ...$args
     * @return mixed
     * @throws \Throwable
     */
    public function invoke(...$args)
    {
        $result = null;
        $error  = null;

        try {
            $result = $this->callClosure(...$args);
        } catch (\Throwable $e) {
            $error = $e;
        }

        if ($this->then) {
            return ($this->then)($result ?? $error);
        }

        if ($error !== null) {
            throw $error;
        }

        return $result;
    }

    /**
     * @param array ...$args
     * @return mixed
     * @throws \Throwable
     */
    private function callClosure(...$args)
    {
        while (
            $this->retries === static::INFINITY_RETRIES ||
            ($this->retries-- + 1) > 0
        ) {
            try {
                return ($this->context)(...$args);
            } catch (\Throwable $e) {
                $this->throw($e, $this->everyError);
/**
 * @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->willBeThrows()) {
                    return $this->throw($e, $this->catches, true);
                }
            }
        }

        return null;
    }

    /**
     * @return bool
     * @throws \Throwable
     */
    private function willBeThrows(): bool
    {
        return $this->retries !== static::INFINITY_RETRIES && $this->retries < 0;
    }

    /**
     * @param \Throwable $e
     * @param array $callbacks
     * @param bool $throwAfter
     * @return mixed
     * @throws \Throwable
     */
    private function throw(\Throwable $e, array $callbacks, bool $throwAfter = false)
    {
        foreach ($callbacks as $name => $callback) {
            if ($e instanceof $name || $name === static::CATCH_ALL_EXCEPTIONS) {
                return $callback($e);
            }
        }

        if ($throwAfter) {
            throw $e;
        }

        return null;
    }

    /**
     * @param \Closure $then
     * @return Evacuator|$this
     */
    public function finally(\Closure $then): Evacuator

    {
        $this->then = $then;

        return $this;
class A {
    var $property;
}
    }
}


1		<?php declare(strict_types = 1);
2		/**
3		* This file is part of Evacuator package.
4		*
5		* For the full copyright and license information, please view the LICENSE
6		* file that was distributed with this source code.
7		*/
8		namespace Serafim\Evacuator;
9
10		/**
11		* Class Evacuator
12		* @package Serafim\Evacuator
13		*/
14		class Evacuator
15		{
16		/**
17		* @var string
18		* @internal
19		*/
20		const CATCH_ALL_EXCEPTIONS = '*';
21
22		/**
23		* @var int
24		*/
25		const INFINITY_RETRIES = -100;
26
27		/**
28		* @var \Closure
29		*/
30		private $context;
31
32		/**
33		* @var int
34		*/
35		private $retries = 0;
36
37		/**
38		* @var array\|\Closure[]
39		*/
40		private $catches = [];
41
42		/**
43		* @var null\|\Closure
44		*/
45		private $then;
46
47		/**
48		* @var array\|\Closure
49		*/
50		private $everyError = [];
51
52		/**
53		* Evacuator constructor.
54		* @param \Closure $context
55		*/
56		public function __construct(\Closure $context)
57		{
58		$this->context = $context;
59		}
60
61		/**
62		* @param array ...$args
63		* @return mixed
64		* @throws \Throwable
65		*/
66		public function __invoke(...$args)
67		{
68		return $this->invoke(...$args);
69		}
70
71		/**
72		* @param int $count
73		* @return Evacuator
74		* @throws \InvalidArgumentException
75		*/
76		public function retries(int $count): Evacuator
77		{
78		if ($count < 0 && $count !== static::INFINITY_RETRIES) {
79		throw new \InvalidArgumentException('Retries count must be greater than 0');
80		}
81
82		$this->retries = $count;
83
84		return $this;
85		}
86
87		/**
88		* @param \Closure $then
89		* @return Evacuator\|$this
90		* @throws \InvalidArgumentException
91		*/
92	View Code Duplication	public function catch(\Closure $then): Evacuator
		0 ignored issues – show Duplication introduced 2016-12-29 19:06 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history... Coding Style introduced 2016-12-29 19:06 UTC by Report Bug Copy Issue Report Possible parse error: non-abstract method defined as abstract Loading history... Coding Style introduced 2016-12-29 19:06 UTC by Report Bug Copy Issue Report It is generally advisable to only define one property per statement. Only declaring a single property per statement allows you to later on add doc comments more easily. It is also recommended by PSR2, so it is a common style that many people expect. Loading history...
93		{
94		$exceptionClass = $this->resolveTypeHint($then, \Throwable::class);
95
96		$this->catches[$exceptionClass] = $then;
		0 ignored issues – show Coding Style introduced 2016-12-29 19:06 UTC by Report Bug Copy Issue Report It is generally advisable to only define one property per statement. Only declaring a single property per statement allows you to later on add doc comments more easily. It is also recommended by PSR2, so it is a common style that many people expect. Loading history... Coding Style introduced 2016-12-29 19:06 UTC by Report Bug Copy Issue Report The visibility should be declared for property `$this`. The PSR-2 coding standard requires that all properties in a class have their visibility explicitly declared. If you declare a property using class A { var $property; } the property is implicitly global. To learn more about the PSR-2, please see the PHP-FIG site on the PSR-2. Loading history...
97
98		return $this;
		0 ignored issues – show Coding Style introduced 2016-12-29 19:06 UTC by Report Bug Copy Issue Report The visibility should be declared for property `$this`. The PSR-2 coding standard requires that all properties in a class have their visibility explicitly declared. If you declare a property using class A { var $property; } the property is implicitly global. To learn more about the PSR-2, please see the PHP-FIG site on the PSR-2. Loading history...
99		}
100
101		/**
102		* @param \Closure $then
103		* @return Evacuator
104		* @throws \InvalidArgumentException
105		*/
106	View Code Duplication	public function onError(\Closure $then): Evacuator
		0 ignored issues – show Duplication introduced 2016-12-29 19:06 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
107		{
108		$exceptionClass = $this->resolveTypeHint($then, \Throwable::class);
109
110		$this->everyError[$exceptionClass] = $then;
111
112		return $this;
113		}
114
115		/**
116		* @param \Closure $closure
117		* @param string $instanceOf
118		* @return string
119		* @throws \InvalidArgumentException
120		*/
121		private function resolveTypeHint(\Closure $closure, string $instanceOf): string
122		{
123		$parameters = (new \ReflectionFunction($closure))->getParameters();
124
125		// Callback has ony one argument
126		if (1 !== count($parameters)) {
127		throw new \InvalidArgumentException(
128		'Closure argument of catch(...) method required ' . (count($parameters) > 1 ? 'only ' :'') .
129		'1 parameter ' . count($parameters) . ' given'
130		);
131		}
132
133		// Callback has no type hints
134		if (null === reset($parameters)->getType()) {
135		return static::CATCH_ALL_EXCEPTIONS;
136		}
137
138		$typeHintClass = reset($parameters)->getClass();
139
140		// Callback has primitive type hint
141		if (null === $typeHintClass) {
142		throw new \InvalidArgumentException(
143		'Closure argument of catch(...) method type hint can not be a primitive'
144		);
145		}
146
147		if (!($typeHintClass->newInstanceWithoutConstructor() instanceof $instanceOf)) {
148		throw new \InvalidArgumentException(
149		'Closure argument of catch(...) method type hint must be instance of ' . $instanceOf .
150		', ' . $typeHintClass->name . ' given'
151		);
152		}
153
154		return $typeHintClass->name;
155		}
156
157		/**
158		* @param array ...$args
159		* @return mixed
160		* @throws \Throwable
161		*/
162		public function invoke(...$args)
163		{
164		$result = null;
165		$error = null;
166
167		try {
168		$result = $this->callClosure(...$args);
169		} catch (\Throwable $e) {
170		$error = $e;
171		}
172
173		if ($this->then) {
174		return ($this->then)($result ?? $error);
175		}
176
177		if ($error !== null) {
178		throw $error;
179		}
180
181		return $result;
182		}
183
184		/**
185		* @param array ...$args
186		* @return mixed
187		* @throws \Throwable
188		*/
189		private function callClosure(...$args)
190		{
191		while (
192		$this->retries === static::INFINITY_RETRIES \|\|
193		($this->retries-- + 1) > 0
194		) {
195		try {
196		return ($this->context)(...$args);
197		} catch (\Throwable $e) {
198		$this->throw($e, $this->everyError);
		0 ignored issues – show Bug introduced 2016-12-29 19:06 UTC by Report Bug Copy Issue Report It seems like `$this->everyError` can also be of type `object<Closure>`; however, `Serafim\Evacuator\Evacuator::throw()` 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...
199
200		if ($this->willBeThrows()) {
201		return $this->throw($e, $this->catches, true);
202		}
203		}
204		}
205
206		return null;
207		}
208
209		/**
210		* @return bool
211		* @throws \Throwable
212		*/
213		private function willBeThrows(): bool
214		{
215		return $this->retries !== static::INFINITY_RETRIES && $this->retries < 0;
216		}
217
218		/**
219		* @param \Throwable $e
220		* @param array $callbacks
221		* @param bool $throwAfter
222		* @return mixed
223		* @throws \Throwable
224		*/
225		private function throw(\Throwable $e, array $callbacks, bool $throwAfter = false)
226		{
227		foreach ($callbacks as $name => $callback) {
228		if ($e instanceof $name \|\| $name === static::CATCH_ALL_EXCEPTIONS) {
229		return $callback($e);
230		}
231		}
232
233		if ($throwAfter) {
234		throw $e;
235		}
236
237		return null;
238		}
239
240		/**
241		* @param \Closure $then
242		* @return Evacuator\|$this
243		*/
244		public function finally(\Closure $then): Evacuator
		0 ignored issues – show Coding Style introduced 2016-12-29 19:06 UTC by Report Bug Copy Issue Report Possible parse error: non-abstract method defined as abstract Loading history... Coding Style introduced 2016-12-29 19:06 UTC by Report Bug Copy Issue Report It is generally advisable to only define one property per statement. Only declaring a single property per statement allows you to later on add doc comments more easily. It is also recommended by PSR2, so it is a common style that many people expect. Loading history...
245		{
246		$this->then = $then;
247
248		return $this;
		0 ignored issues – show Coding Style introduced 2016-12-29 19:06 UTC by Report Bug Copy Issue Report The visibility should be declared for property `$this`. The PSR-2 coding standard requires that all properties in a class have their visibility explicitly declared. If you declare a property using class A { var $property; } the property is implicitly global. To learn more about the PSR-2, please see the PHP-FIG site on the PSR-2. Loading history...
249		}
250		}
251

SerafimArts / Evacuator

Evacuator::__construct() A last analyzed 2016-12-29 19:11 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Evacuator::__construct() A
last analyzed 2016-12-29 19:11 UTC