Dgame\Ensurance\EnsuranceTrait

Complexity

Total Complexity

23

Size/Duplication

Total Lines	197
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	__destruct()	0	6	2
A	is()	0	10	2
A	isTypeOf()	0	6	1
A	then()	0	4	2
A	else()	0	4	2
A	either()	0	4	1
A	get()	0	4	1
A	ensure()	0	6	1
A	isEnsured()	0	4	1
A	disregardThrowable()	0	6	1
A	releaseThrowable()	0	8	1
A	transferEnsurance()	0	10	2
A	orThrow()	0	8	2
A	hasThrowable()	0	4	1
A	setThrowable()	0	8	2
A	getThrowable()	0	4	1

<?php

namespace Dgame\Ensurance;

use Dgame\Ensurance\Exception\EnsuranceException;
use Dgame\Type\Type;
use Throwable;

/**
 * Trait EnsuranceTrait
 * @package Dgame\Ensurance
 */
trait EnsuranceTrait
{
    /**
     * @var mixed
     */
    private $value;
    /**
     * @var bool
     */
    private $ensured = true;
    /**
     * @var Throwable
     */
    private $throwable;

    /**
     *
     */
    public function __destruct()
    {
        if ($this->hasThrowable()) {
            throw $this->throwable;
        }
    }

    /**
     * @param callable $callback
     *
     * @return self
     */
    final public function is(callable $callback): self
    {
        try {
            $result = (bool) $callback($this->value);
        } catch (Throwable $t) {
            $result = false;
        }

        return $this->ensure($result);
    }

    /**
     * @param string $type
     *
     * @return EnsuranceTrait

The return type EnsuranceTrait is a trait, and thus cannot be used for type-hinting in PHP. Maybe consider adding an interface and use that for type-hinting?

     * @throws \Exception
     */
    final public function isTypeOf(string $type): self
    {
        $type = Type::import($type);

Consider using a different name than the parameter $type. This often makes code more readable.

        return $this->ensure($type->accept($this->value));
    }

    /**
     * @param $value
     *
     * @return mixed
     */
    final public function then($value)
    {
        return $this->disregardThrowable()->isEnsured() ? $value : $this->value;
    }

    /**
     * @param $value
     *
     * @return mixed
     */
    final public function else($value)

Possible parse error: non-abstract method defined as abstract

It is generally advisable to only define one property per statement.

    {
        return $this->disregardThrowable()->isEnsured() ? $this->value : $value;
    }

    /**
     * @param $value
     *
     * @return Either
     */
    final public function either($value): Either
    {
        return new Either($value, $this->disregardThrowable()->isEnsured());
    }

    /**
     * @param mixed $default
     *
     * @return mixed
     */
    final public function get($default = null)
    {
        return $this->value ?? $default;
    }

    /**
     * @param bool $condition
     *
     * @return self
     */
    final protected function ensure(bool $condition): self
    {
        $this->ensured = $condition;

        return $this;
    }

    /**
     * @return bool
     */
    final public function isEnsured(): bool
    {
        return $this->ensured;
    }

    /**
     * @return self
     */
    final public function disregardThrowable(): self
    {
        $this->throwable = null;

        return $this;
    }

    /**
     * @return Throwable
     */
    final public function releaseThrowable(): Throwable
    {
        try {
            return $this->throwable;
        } finally {
            $this->disregardThrowable();

$this->disregardThrowable(); does not seem to be reachable.

        }
    }

    /**
     * @param EnsuranceInterface $ensurance
     *
     * @return self
     */
    final public function transferEnsurance(EnsuranceInterface $ensurance): self
    {
        $this->value = $ensurance->get();
        $this->ensure($ensurance->isEnsured());
        if ($ensurance->hasThrowable()) {
            $this->setThrowable($ensurance->releaseThrowable());
        }

        return $this;
    }

    /**
     * @param string $message
     * @param mixed  ...$args
     *
     * @return self
     */

Consider making the type for parameter $args a bit more specific; maybe use array.

    final public function orThrow(string $message, ...$args): self
    {
        if (!$this->isEnsured()) {
            $this->setThrowable(new EnsuranceException(format($message, ...$args), $this->throwable));
        }

        return $this;
    }

    /**
     * @return bool
     */
    final public function hasThrowable(): bool
    {
        return $this->throwable !== null;
    }

    /**
     * @param Throwable $throwable
     *
     * @return self
     */
    final public function setThrowable(Throwable $throwable): self
    {
        if (!$this->isEnsured()) {
            $this->throwable = $throwable;
        }

        return $this;
    }

    /**
     * @return Throwable
     */
    final public function getThrowable(): Throwable
    {
        return $this->throwable;
    }
}