Dazzle\Promise\PromiseCancelled

Complexity

Total Complexity

29

Size/Duplication

Total Lines	247
Duplicated Lines	12.55 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

92%

Importance

Changes

0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	2
A	__destruct()	0	4	1
B	then()	0	26	4
A	done()	19	19	4
A	spread()	0	10	1
A	success()	0	4	1
A	failure()	0	4	1
A	abort()	0	4	1
A	always()	12	12	1
A	isPending()	0	4	1
A	isFulfilled()	0	4	1
A	isRejected()	0	4	1
A	isCancelled()	0	4	1
A	getPromise()	0	4	1
A	resolve()	0	4	1
A	reject()	0	4	1
A	cancel()	0	4	1
A	getValue()	0	4	1
A	getReason()	0	4	1
A	throwError()	0	9	3

<?php

namespace Dazzle\Promise;

use Dazzle\Throwable\Exception\Logic\InvalidArgumentException;
use Dazzle\Throwable\Exception\Runtime\CancellationException;
use Error;
use Exception;

class PromiseCancelled implements PromiseInterface
{
    /**
     * @var Error|Exception|string|null
     */
    protected $reason;

    /**
     * @param Error|Exception|string|null $reason
     * @throws InvalidArgumentException
     */
    public function __construct($reason = null)
    {
        if ($reason instanceof PromiseInterface)
        {
            throw new InvalidArgumentException(
                'You cannot create PromiseCancelled with a promise. Use Promise::doCancel($promiseOrValue) instead.'
            );
        }

        $this->reason = $reason;
    }

    /**
     *
     */
    public function __destruct()
    {
        unset($this->reason);
    }

    /**
     * @override
     * @inheritDoc
     */
    public function then(callable $onFulfilled = null, callable $onRejected = null, callable $onCancel = null)
    {
        if (null === $onCancel)
        {
            return $this;
        }

        try
        {
            return Promise::doResolve($onCancel($this->getReason()))
                ->then(
                    function() {
                        return Promise::doCancel($this->getReason());
                    },
                    function() {
                        return Promise::doCancel($this->getReason());
                    }
                );
        }
        catch (Error $ex)

Consider adding a comment why this CATCH block is empty.

        {}
        catch (Exception $ex)

Consider adding a comment why this CATCH block is empty.

        {}

        return Promise::doCancel($this->getReason());
    }

    /**
     * @override
     * @inheritDoc
     */
    public function done(callable $onFulfilled = null, callable $onRejected = null, callable $onCancel = null)

This method seems to be duplicated in your project.

    {
        if (null === $onCancel)
        {
            $this->throwError($this->getReason());

It seems like $this->getReason() targeting Dazzle\Promise\PromiseCancelled::getReason() can also be of type null; however, Dazzle\Promise\PromiseCancelled::throwError() does only seem to accept object<Exception>|string, maybe add an additional type check?

        }

        $result = $onCancel($this->getReason());

        if ($result instanceof self)
        {
            $this->throwError($result->getReason());

It seems like $result->getReason() targeting Dazzle\Promise\PromiseCancelled::getReason() can also be of type null; however, Dazzle\Promise\PromiseCancelled::throwError() does only seem to accept object<Exception>|string, maybe add an additional type check?

        }

        if ($result instanceof PromiseInterface)
        {
            $result->done();
        }
    }

    /**
     * @override
     * @inheritDoc
     */
    public function spread(callable $onFulfilled = null, callable $onRejected = null, callable $onCancel = null)
    {
        return $this->then(
            null,
            null,
            function($reasons) use($onCancel) {
                return $onCancel(...((array) $reasons));
            }
        );
    }

    /**
     * @override
     * @inheritDoc
     */
    public function success(callable $onSuccess)
    {
        return $this->then($onSuccess);
    }

    /**
     * @override
     * @inheritDoc
     */
    public function failure(callable $onFailure)
    {
        return $this->then(null, $onFailure);
    }

    /**
     * @override
     * @inheritDoc
     */
    public function abort(callable $onCancel)
    {
        return $this->then(null, null, $onCancel);
    }

    /**
     * @override
     * @inheritDoc
     */
    public function always(callable $onFulfilledOrRejected)

This method seems to be duplicated in your project.

    {
        return $this->then(
            null,
            null,
            function($reason) use($onFulfilledOrRejected) {
                return Promise::doResolve($onFulfilledOrRejected())->then(function() use($reason) {
                    return new static($reason);
                });
            }
        );
    }

    /**
     * @override
     * @inheritDoc
     */
    public function isPending()
    {
        return false;
    }

    /**
     * @override
     * @inheritDoc
     */
    public function isFulfilled()
    {
        return false;
    }

    /**
     * @override
     * @inheritDoc
     */
    public function isRejected()
    {
        return false;
    }

    /**
     * @override
     * @inheritDoc
     */
    public function isCancelled()
    {
        return true;
    }

    /**
     * @override
     * @inheritDoc
     */
    public function getPromise()
    {
        return $this;
    }

    /**
     * @override
     * @inheritDoc
     */
    public function resolve($value = null)
    {
        return $this;
    }

    /**
     * @override
     * @inheritDoc
     */
    public function reject($reason = null)
    {
        return $this;
    }

    /**
     * @override
     * @inheritDoc
     */
    public function cancel($reason = null)
    {
        return $this;
    }

    /**
     * @see Promise::getValue
     */
    protected function getValue()
    {
        return null;
    }

    /**
     * @see Promise::getReason
     */
    protected function getReason()
    {
        return $this->reason;
    }

    /**
     * @param Error|Exception|string $reason
     * @throws Error|Exception
     */
    protected function throwError($reason)
    {
        if ($reason instanceof Error || $reason instanceof Exception)
        {
            throw $reason;
        }

        throw new CancellationException($reason);
    }
}