Dazzle\Promise\PromiseRejected

Complexity

Total Complexity

30

Size/Duplication

Total Lines	239
Duplicated Lines	20.92 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

86.76%

Importance

Changes

0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	2
A	__destruct()	0	4	1
A	then()	20	20	4
A	done()	19	19	4
A	spread()	0	9	1
A	success()	0	4	1
A	failure()	0	4	1
A	abort()	0	4	1
A	always()	11	11	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	2
A	throwError()	0	9	3

<?php

namespace Dazzle\Promise;

use Dazzle\Throwable\Exception\Logic\InvalidArgumentException;
use Dazzle\Throwable\Exception\Runtime\RejectionException;
use Dazzle\Throwable\ThrowableProxy;
use Error;
use Exception;

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

    /**
     * @param Error|Exception|string|null
     * @throws InvalidArgumentException
     */
    public function __construct($reason = null)
    {
        if ($reason instanceof PromiseInterface)
        {
            throw new InvalidArgumentException(
                'You cannot create PromiseRejected with a promise. Use Promise::doReject($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)

This method seems to be duplicated in your project.

    {
        if (null === $onRejected)
        {
            return $this;
        }

        try
        {
            return Promise::doResolve($onRejected($this->getReason()));
        }
        catch (Error $ex)
        {
            return new PromiseRejected($ex);
        }
        catch (Exception $ex)
        {
            return new PromiseRejected($ex);
        }
    }

    /**
     * @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 === $onRejected)
        {
            $this->throwError($this->getReason());

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

        }

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

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

It seems like $result->getReason() targeting Dazzle\Promise\PromiseRejected::getReason() can also be of type null; however, Dazzle\Promise\PromiseRejected::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,
            function($rejections) use($onRejected) {
                return $onRejected(...((array) $rejections));
            }
        );
    }

    /**
     * @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,
            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 true;
    }

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

    /**
     * @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 instanceof ThrowableProxy) ? $this->reason->toThrowable() : $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 RejectionException($reason);
    }
}