Dgame\Ensurance\Enforcement\Enforcement

Complexity

Total Complexity

15

Size/Duplication

Total Lines	116
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	1

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	2
A	__destruct()	0	6	2
A	approve()	0	4	1
A	isFulfilled()	0	4	1
A	hasThrowable()	0	4	1
A	getThrowable()	0	4	1
A	emplaceThrowable()	0	4	1
A	orThrow()	0	8	2
A	setThrowMessage()	0	13	3
A	setThrowable()	0	4	1

<?php

namespace Dgame\Ensurance\Enforcement;

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

/**
 * Class Enforcement
 * @package Dgame\Ensurance\Enforcement
 */
final class Enforcement
{
    /**
     * @var bool
     */
    private $condition;
    /**
     * @var null|Throwable
     */
    private $throwable;

    /**
     * Enforcement constructor.
     *
     * @param bool        $condition
     * @param string|null $message
     */
    public function __construct(bool $condition, string $message = null)
    {
        $this->condition = $condition;
        if ($message !== null) {
            $this->setThrowMessage($message);
        }
    }

    /**
     * @throws Throwable
     */
    public function __destruct()
    {
        if (!$this->isFulfilled()) {
            throw $this->getThrowable();
        }
    }

    /**
     * Enforce approvement of the Enforcement
     */
    final public function approve()

Unnecessary FINAL modifier in FINAL class

    {
        $this->condition = true;
    }

    /**
     * @return bool
     */
    final public function isFulfilled(): bool

Unnecessary FINAL modifier in FINAL class

    {
        return $this->condition;
    }

    /**
     * @return bool
     */
    final public function hasThrowable(): bool

Unnecessary FINAL modifier in FINAL class

    {
        return $this->throwable !== null;
    }

    /**
     * @return Throwable
     */
    private function getThrowable(): Throwable
    {
        return $this->throwable ?? $this->emplaceThrowable('Assertion failed');
    }

    /**
     * @param string $message
     *
     * @return Throwable
     */
    private function emplaceThrowable(string $message): Throwable
    {
        return new EnsuranceException($message);
    }

    /**
     * @param string|Throwable $throwable
     * @param array            ...$args
     */

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

    final public function orThrow($throwable, ...$args)

Unnecessary FINAL modifier in FINAL class

    {
        if ($throwable instanceof Throwable) {
            $this->setThrowable($throwable);
        } else {
            $this->setThrowMessage((string) $throwable, ...$args);
        }
    }

    /**
     * @param string $message
     * @param array  ...$args
     */

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

    final public function setThrowMessage(string $message, ...$args)

Unnecessary FINAL modifier in FINAL class

    {
        if (!empty($args)) {
            $args    = array_map(function ($arg) {

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

                return !is_string($arg) ? var_export($arg, true) : $arg;
            }, $args);
            $message = sprintf($message, ...$args);

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

        }

        $throwable = $this->emplaceThrowable($message);

        $this->setThrowable($throwable);
    }

    /**
     * @param Throwable $throwable
     */
    final public function setThrowable(Throwable $throwable)

Unnecessary FINAL modifier in FINAL class

    {
        $this->throwable = $throwable;
    }
}