Promise::waitInPendingState() - Code Metrics - plvhx/promise - Measure and Improve Code Quality continuously with Scrutinizer

Promise::waitInPendingState() B
last analyzed 2017-09-25 18:12 UTC

↳ Parent: Promise

Complexity

Conditions	6
Paths	8

Size

Total Lines	26
Code Lines	17

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	26
rs	8.439
cc	6
eloc	17
nc	8
nop	0

<?php

namespace Gandung\Promise;

/**
 * @author Paulus Gandung Prakosa <[email protected]>
 */
class Promise implements PromiseInterface
{
    /**
     * @var integer
     */
    private $state = self::STATE_PENDING;

    /**
     * @var mixed
     */
    private $current;

    /**
     * @var array
     */
    private $context = [];

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

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

    /**
     * @var boolean
     */
    private $isStateTransformed;

    /**
     * Appends fulfillment and rejection handlers to the promise, and returns an immutable
     * new promise resolving to the return value of the handler.
     *
     * @param \Closure $onFulfilled Callback to be called when promise state is fulfilled.
     * @param \Closure $onRejected Callback to be called when promise state is rejected.
     * @return Promise
     */
    public function then($onFulfilled = null, $onRejected = null)
    {
        if ($this->state === self::STATE_PENDING) {
            $q = new Promise();
            $this->context[] = [$q, $onFulfilled, $onRejected];

            return $q;
        }

        if ($this->state === self::STATE_FULFILLED) {
            return $onFulfilled

                ? (new FulfilledPromise($this->current))->then($onFulfilled, null)
                : new FulfilledPromise($this->current);
        }

        return $onRejected

            ? (new RejectedPromise($this->current))->then(null, $onRejected)
            : new RejectedPromise($this->current);
    }

    /**
     * Set waiting callback.
     *
     * @param \Closure $callback Callback to be set.
     * @return void
     */
    public function setWaitCallback(\Closure $callback = null)
    {
        if (!($callback instanceof \Closure)) {
            throw new \InvalidArgumentException(
                sprintf("Parameter 1 of %s must be a valid callback.", __METHOD__)
            );
        }

        $this->waitCallback = $callback;
    }

    /**
     * Set cancellation callback.
     *
     * @param \Closure $callback Callback to be set.
     * @return void
     */
    public function setCancelCallback(\Closure $callback = null)
    {
        if (!($callback instanceof \Closure)) {
            throw new \InvalidArgumentException(
                sprintf("Parameter 1 of %s must be a valid callback.", __METHOD__)
            );
        }

        $this->cancelCallback = $callback;
    }

    /**
     * Comparing current promise state to new state and current promise value
     * to new value.
     *
     * @param mixed $value Value to be compare.
     * @param integer $state New promise state to be compare.
     * @return null|boolean
     */
    private function validateState($value, $state)
    {
        if ($this->state !== self::STATE_PENDING) {
            if ($value === $this->current && $state === $this->state) {
                return null;
            }

            $prevStatus = $this->state;
            $currentStatus = $state;

            throw $this->state === $state
                ? new \LogicException(
                    sprintf("State of the promise is already %s", $prevStatus == 4 ? 'fulfilled' : 'rejected')
                )
                : new \LogicException(
                    sprintf(
                        "Unable to change %s promise to %s",
                        $prevStatus == 4 ? 'fulfilled' : 'rejected',
                        $currentStatus == 4 ? 'fulfilled' : 'rejected'
                    )
                );
        }

        if ($value === $this) {
            throw new \LogicException(
                "Unable to fulfill or reject a promise with itself."
            );
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function resolve($value)
    {
        $this->isStateTransformed = $this->validateState($value, self::STATE_FULFILLED);

        if ($this->isStateTransformed) {
            $this->setState(self::STATE_FULFILLED);
            $this->trigger($value);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function reject($reason)
    {
        $this->isStateTransformed = $this->validateState($reason, self::STATE_REJECTED);

        if ($this->isStateTransformed) {
            $this->setState(self::STATE_REJECTED);
            $this->trigger($reason);
        }
    }

    /**
     * Synchronously forces promise to complete using wait method.
     *
     * @return mixed
     */
    public function wait()
    {
        $this->waitInPendingState();

        $q = $this->current instanceof PromiseInterface
            ? $this->current->wait()
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
            : $this->current;

        if ($this->current instanceof PromiseInterface || $this->currentState() === self::STATE_FULFILLED) {
            return $q;
        } else {
            throw $q instanceof \Exception
                ? $q
                : new \Exception($q);
        }
    }

    /**
     * Cancel a promise that has not yet been fulfilled.
     *
     * @return mixed
     */
    public function cancel()
    {
        if ($this->currentState() !== self::STATE_PENDING) {
            return;
        }

        if ($this->cancelCallback) {
            $cancelCallback = $this->cancelCallback;
            $this->cancelCallback = null;

            try {
                $cancelCallback();
            } catch (\Exception $e) {
                $this->reject($e);
            }
        }

        if ($this->currentState() === self::STATE_PENDING) {
            $this->reject('Promise has been cancelled.');
        }

        $e = $this->current instanceof PromiseInterface
            ? $this->current->cancel()
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
            : $this->current;

        if ($this->current instanceof PromiseInterface || $this->currentState() === self::STATE_REJECTED) {
            return $e;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function currentState()
    {
        return $this->state;
    }

    /**
     * Invoking promise handler based on current state and given value.
     *
     * @param mixed $value
     * @return void
     */
    private function trigger($value)
    {
        $context = $this->context;
        $this->context = null;

        $this->current = $value;
        $this->waitCallback = null;
        $this->cancelCallback = null;

        if (!method_exists($value, 'then')) {
            $index = $this->state === self::STATE_FULFILLED ? 1 : 2;

            Context\ContextStack::create()->store(
            static function () use ($index, $context, $value) {
                foreach ($context as $c) {
                    self::invokeContext($c, $index, $value);
                }
            });

            Context\ContextStack::getQueueHandler()->run();

        } elseif ($value instanceof Promise && $value->currentState() === self::STATE_PENDING) {
            $value->context = array_merge($value->context, $context);
        } else {
            $value->then(
            static function ($value) use ($context) {
                foreach ($context as $c) {
                    self::invokeContext($c, 1, $value);
                }
            },
            static function ($reason) use ($context) {
                foreach ($context as $c) {
                    self::invokeContext($c, 2, $reason);
                }
            }
            );
        }
    }

    /**
     * Invoking handler based on given context, index, and value.
     *
     * @param array $context
     * @param integer $index
     * @param mixed $value
     * @return void
     */
    private static function invokeContext($context, $index, $value)
    {
        $promise = $context[0];

        if ($promise->currentState() !== self::STATE_PENDING) {
            return;
        }

        try {
            if (isset($context[$index])) {
                $promise->resolve($context[$index]($value));
            } elseif ($index === 1) {
                $promise->resolve($value);
            } else {
                $promise->reject($value);
            }
        } catch (\Throwable $e) {

            $promise->reject($e);
        } catch (\Exception $e) {
            $promise->reject($e);
        }
    }

    /**
     * Set promise state to given state.
     *
     * @param integer $state
     * @return void
     */
    private function setState($state)
    {
        if ($state !== self::STATE_PENDING &&
            $state !== self::STATE_FULFILLED &&
            $state !== self::STATE_REJECTED) {
            throw new \InvalidArgumentException(
                sprintf("Parameter 1 of %s must be a valid promise state.", __METHOD__)
            );
        }

        $this->state = $state;
    }

    /**
     * Synchronously forces promise to wait when current promise state is pending.
     *
     * @return void
     */
    private function waitInPendingState()
    {
        if ($this->currentState() !== self::STATE_PENDING) {
            return;
        } elseif ($this->waitCallback) {
            try {
                $waitCallback = $this->waitCallback;
                $this->waitCallback = null;
                $waitCallback();
            } catch (\Exception $e) {
                if ($this->currentState() === self::STATE_PENDING) {
                    $this->reject($e);
                } else {
                    throw $e;
                }
            }
        }

        Context\ContextStack::getQueueHandler()->run();


        if ($this->currentState() === self::STATE_PENDING) {
            $this->reject(
                'Invoking the synchronous wait callback resolver didn\'t resolve the current promise'
            );
        }
    }
}


GitHub Access Token became invalid

Promise::waitInPendingState() B
last analyzed 2017-09-25 18:12 UTC

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

1			<?php
2
3			namespace Gandung\Promise;
4
5			/**
6			* @author Paulus Gandung Prakosa <[email protected]>
7			*/
8			class Promise implements PromiseInterface
9			{
10			/**
11			* @var integer
12			*/
13			private $state = self::STATE_PENDING;
14
15			/**
16			* @var mixed
17			*/
18			private $current;
19
20			/**
21			* @var array
22			*/
23			private $context = [];
24
25			/**
26			* @var \Closure
27			*/
28			private $waitCallback;
29
30			/**
31			* @var \Closure
32			*/
33			private $cancelCallback;
34
35			/**
36			* @var boolean
37			*/
38			private $isStateTransformed;
39
40			/**
41			* Appends fulfillment and rejection handlers to the promise, and returns an immutable
42			* new promise resolving to the return value of the handler.
43			*
44			* @param \Closure $onFulfilled Callback to be called when promise state is fulfilled.
45			* @param \Closure $onRejected Callback to be called when promise state is rejected.
46			* @return Promise
47			*/
48			public function then($onFulfilled = null, $onRejected = null)
49			{
50			if ($this->state === self::STATE_PENDING) {
51			$q = new Promise();
52			$this->context[] = [$q, $onFulfilled, $onRejected];
53
54			return $q;
55			}
56
57			if ($this->state === self::STATE_FULFILLED) {
58			return $onFulfilled
			0 ignored issues – show Bug Compatibility introduced 2017-08-12 16:48 UTC by Report Bug Copy Issue Report The expression `$onFulfilled ? (new \Gan...romise($this->current);` of type `Gandung\Promise\Promise\|...romise\FulfilledPromise` adds the type `Gandung\Promise\FulfilledPromise` to the return on line 58 which is incompatible with the return type declared by the interface `Gandung\Promise\PromiseInterface::then` of type `Gandung\Promise\Promise`. Loading history...
59			? (new FulfilledPromise($this->current))->then($onFulfilled, null)
60			: new FulfilledPromise($this->current);
61			}
62
63			return $onRejected
			0 ignored issues – show Bug Compatibility introduced 2017-08-12 16:48 UTC by Report Bug Copy Issue Report The expression `$onRejected ? (new \Gand...romise($this->current);` of type `Gandung\Promise\Promise\|...Promise\RejectedPromise` adds the type `Gandung\Promise\RejectedPromise` to the return on line 63 which is incompatible with the return type declared by the interface `Gandung\Promise\PromiseInterface::then` of type `Gandung\Promise\Promise`. Loading history...
64			? (new RejectedPromise($this->current))->then(null, $onRejected)
65			: new RejectedPromise($this->current);
66			}
67
68			/**
69			* Set waiting callback.
70			*
71			* @param \Closure $callback Callback to be set.
72			* @return void
73			*/
74			public function setWaitCallback(\Closure $callback = null)
75			{
76			if (!($callback instanceof \Closure)) {
77			throw new \InvalidArgumentException(
78			sprintf("Parameter 1 of %s must be a valid callback.", __METHOD__)
79			);
80			}
81
82			$this->waitCallback = $callback;
83			}
84
85			/**
86			* Set cancellation callback.
87			*
88			* @param \Closure $callback Callback to be set.
89			* @return void
90			*/
91			public function setCancelCallback(\Closure $callback = null)
92			{
93			if (!($callback instanceof \Closure)) {
94			throw new \InvalidArgumentException(
95			sprintf("Parameter 1 of %s must be a valid callback.", __METHOD__)
96			);
97			}
98
99			$this->cancelCallback = $callback;
100			}
101
102			/**
103			* Comparing current promise state to new state and current promise value
104			* to new value.
105			*
106			* @param mixed $value Value to be compare.
107			* @param integer $state New promise state to be compare.
108			* @return null\|boolean
109			*/
110			private function validateState($value, $state)
111			{
112			if ($this->state !== self::STATE_PENDING) {
113			if ($value === $this->current && $state === $this->state) {
114			return null;
115			}
116
117			$prevStatus = $this->state;
118			$currentStatus = $state;
119
120			throw $this->state === $state
121			? new \LogicException(
122			sprintf("State of the promise is already %s", $prevStatus == 4 ? 'fulfilled' : 'rejected')
123			)
124			: new \LogicException(
125			sprintf(
126			"Unable to change %s promise to %s",
127			$prevStatus == 4 ? 'fulfilled' : 'rejected',
128			$currentStatus == 4 ? 'fulfilled' : 'rejected'
129			)
130			);
131			}
132
133			if ($value === $this) {
134			throw new \LogicException(
135			"Unable to fulfill or reject a promise with itself."
136			);
137			}
138
139			return true;
140			}
141
142			/**
143			* {@inheritdoc}
144			*/
145			public function resolve($value)
146			{
147			$this->isStateTransformed = $this->validateState($value, self::STATE_FULFILLED);
148
149			if ($this->isStateTransformed) {
150			$this->setState(self::STATE_FULFILLED);
151			$this->trigger($value);
152			}
153			}
154
155			/**
156			* {@inheritdoc}
157			*/
158			public function reject($reason)
159			{
160			$this->isStateTransformed = $this->validateState($reason, self::STATE_REJECTED);
161
162			if ($this->isStateTransformed) {
163			$this->setState(self::STATE_REJECTED);
164			$this->trigger($reason);
165			}
166			}
167
168			/**
169			* Synchronously forces promise to complete using wait method.
170			*
171			* @return mixed
172			*/
173			public function wait()
174			{
175			$this->waitInPendingState();
176
177			$q = $this->current instanceof PromiseInterface
178			? $this->current->wait()
			0 ignored issues – show Bug introduced 2017-08-11 15:51 UTC by Report Bug Copy Issue Report It seems like you code against a concrete implementation and not the interface `Gandung\Promise\PromiseInterface` as the method `wait()` does only exist in the following implementations of said interface: `Gandung\Promise\Promise`. Let’s take a look at an example: interface User { /** @return string / public function getPassword(); } class MyUser implements User { public function getPassword() { // return something } public function getDisplayName() { // return some name. } } class AuthSystem { public function authenticate(User $user) { $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName())); // do something. } } In the above example, the authenticate() method works fine as long as you just pass instances of MyUser. However, if you now also want to pass a different implementation of User which does not have a getDisplayName() method, the code will break. Available Fixes Change the type-hint for the parameter: class AuthSystem { public function authenticate(MyUser $user) { / ... / } } Add an additional type-check: class AuthSystem { public function authenticate(User $user) { if ($user instanceof MyUser) { $this->logger->info(/* ... /); } // or alternatively if ( ! $user instanceof MyUser) { throw new \LogicException( '$user must be an instance of MyUser, ' .'other instances are not supported.' ); } } } Note:* PHP Analyzer uses reverse abstract interpretation to narrow down the types inside the if block in such a case. Add the method to the interface: interface User { /** @return string / public function getPassword(); /* @return string */ public function getDisplayName(); } Loading history...
179			: $this->current;
180
181			if ($this->current instanceof PromiseInterface \|\| $this->currentState() === self::STATE_FULFILLED) {
182			return $q;
183			} else {
184			throw $q instanceof \Exception
185			? $q
186			: new \Exception($q);
187			}
188			}
189
190			/**
191			* Cancel a promise that has not yet been fulfilled.
192			*
193			* @return mixed
194			*/
195			public function cancel()
196			{
197			if ($this->currentState() !== self::STATE_PENDING) {
198			return;
199			}
200
201			if ($this->cancelCallback) {
202			$cancelCallback = $this->cancelCallback;
203			$this->cancelCallback = null;
204
205			try {
206			$cancelCallback();
207			} catch (\Exception $e) {
208			$this->reject($e);
209			}
210			}
211
212			if ($this->currentState() === self::STATE_PENDING) {
213			$this->reject('Promise has been cancelled.');
214			}
215
216			$e = $this->current instanceof PromiseInterface
217			? $this->current->cancel()
			0 ignored issues – show Bug introduced 2017-08-11 15:51 UTC by Report Bug Copy Issue Report It seems like you code against a concrete implementation and not the interface `Gandung\Promise\PromiseInterface` as the method `cancel()` does only exist in the following implementations of said interface: `Gandung\Promise\Promise`. Let’s take a look at an example: interface User { /** @return string / public function getPassword(); } class MyUser implements User { public function getPassword() { // return something } public function getDisplayName() { // return some name. } } class AuthSystem { public function authenticate(User $user) { $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName())); // do something. } } In the above example, the authenticate() method works fine as long as you just pass instances of MyUser. However, if you now also want to pass a different implementation of User which does not have a getDisplayName() method, the code will break. Available Fixes Change the type-hint for the parameter: class AuthSystem { public function authenticate(MyUser $user) { / ... / } } Add an additional type-check: class AuthSystem { public function authenticate(User $user) { if ($user instanceof MyUser) { $this->logger->info(/* ... /); } // or alternatively if ( ! $user instanceof MyUser) { throw new \LogicException( '$user must be an instance of MyUser, ' .'other instances are not supported.' ); } } } Note:* PHP Analyzer uses reverse abstract interpretation to narrow down the types inside the if block in such a case. Add the method to the interface: interface User { /** @return string / public function getPassword(); /* @return string */ public function getDisplayName(); } Loading history...
218			: $this->current;
219
220			if ($this->current instanceof PromiseInterface \|\| $this->currentState() === self::STATE_REJECTED) {
221			return $e;
222			}
223			}
224
225			/**
226			* {@inheritdoc}
227			*/
228			public function currentState()
229			{
230			return $this->state;
231			}
232
233			/**
234			* Invoking promise handler based on current state and given value.
235			*
236			* @param mixed $value
237			* @return void
238			*/
239			private function trigger($value)
240			{
241			$context = $this->context;
242			$this->context = null;
			0 ignored issues – show Documentation Bug introduced 2017-08-09 20:36 UTC by Report Bug Copy Issue Report It seems like `null` of type `null` is incompatible with the declared type `array` of property `$context`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
243			$this->current = $value;
244			$this->waitCallback = null;
245			$this->cancelCallback = null;
246
247			if (!method_exists($value, 'then')) {
248			$index = $this->state === self::STATE_FULFILLED ? 1 : 2;
249
250			Context\ContextStack::create()->store(
251			static function () use ($index, $context, $value) {
252			foreach ($context as $c) {
253			self::invokeContext($c, $index, $value);
254			}
255			});
256
257			Context\ContextStack::getQueueHandler()->run();
			0 ignored issues – show Bug introduced 2017-08-09 20:36 UTC by Report Bug Copy Issue Report The method `run` cannot be called on `\Gandung\Promise\Context...tack::getQueueHandler()` (of type `array`). Methods can only be called on objects. This check looks for methods being called on variables that have been inferred to never be objects. Loading history...
258			} elseif ($value instanceof Promise && $value->currentState() === self::STATE_PENDING) {
259			$value->context = array_merge($value->context, $context);
260			} else {
261			$value->then(
262			static function ($value) use ($context) {
263			foreach ($context as $c) {
264			self::invokeContext($c, 1, $value);
265			}
266			},
267			static function ($reason) use ($context) {
268			foreach ($context as $c) {
269			self::invokeContext($c, 2, $reason);
270			}
271			}
272			);
273			}
274			}
275
276			/**
277			* Invoking handler based on given context, index, and value.
278			*
279			* @param array $context
280			* @param integer $index
281			* @param mixed $value
282			* @return void
283			*/
284			private static function invokeContext($context, $index, $value)
285			{
286			$promise = $context[0];
287
288			if ($promise->currentState() !== self::STATE_PENDING) {
289			return;
290			}
291
292			try {
293			if (isset($context[$index])) {
294			$promise->resolve($context[$index]($value));
295			} elseif ($index === 1) {
296			$promise->resolve($value);
297			} else {
298			$promise->reject($value);
299			}
300			} catch (\Throwable $e) {
			0 ignored issues – show Bug introduced 2017-08-11 19:26 UTC by Report Bug Copy Issue Report The class `Throwable` does not exist. Did you forget a USE statement, or did you not list all dependencies? Scrutinizer analyzes your `composer.json`/`composer.lock` file if available to determine the classes, and functions that are defined by your dependencies. It seems like the listed class was neither found in your dependencies, nor was it found in the analyzed files in your repository. If you are using some other form of dependency management, you might want to disable this analysis. Loading history...
301			$promise->reject($e);
302			} catch (\Exception $e) {
303			$promise->reject($e);
304			}
305			}
306
307			/**
308			* Set promise state to given state.
309			*
310			* @param integer $state
311			* @return void
312			*/
313			private function setState($state)
314			{
315			if ($state !== self::STATE_PENDING &&
316			$state !== self::STATE_FULFILLED &&
317			$state !== self::STATE_REJECTED) {
318			throw new \InvalidArgumentException(
319			sprintf("Parameter 1 of %s must be a valid promise state.", __METHOD__)
320			);
321			}
322
323			$this->state = $state;
324			}
325
326			/**
327			* Synchronously forces promise to wait when current promise state is pending.
328			*
329			* @return void
330			*/
331			private function waitInPendingState()
332			{
333			if ($this->currentState() !== self::STATE_PENDING) {
334			return;
335			} elseif ($this->waitCallback) {
336			try {
337			$waitCallback = $this->waitCallback;
338			$this->waitCallback = null;
339			$waitCallback();
340			} catch (\Exception $e) {
341			if ($this->currentState() === self::STATE_PENDING) {
342			$this->reject($e);
343			} else {
344			throw $e;
345			}
346			}
347			}
348
349			Context\ContextStack::getQueueHandler()->run();
			0 ignored issues – show Bug introduced 2017-08-09 20:36 UTC by Report Bug Copy Issue Report The method `run` cannot be called on `\Gandung\Promise\Context...tack::getQueueHandler()` (of type `array`). Methods can only be called on objects. This check looks for methods being called on variables that have been inferred to never be objects. Loading history...
350
351			if ($this->currentState() === self::STATE_PENDING) {
352			$this->reject(
353			'Invoking the synchronous wait callback resolver didn\'t resolve the current promise'
354			);
355			}
356			}
357			}
358

plvhx / promise

GitHub Access Token became invalid

Promise::waitInPendingState() B last analyzed 2017-09-25 18:12 UTC

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like

Promise::waitInPendingState() B
last analyzed 2017-09-25 18:12 UTC