Seboettg\Collection\Assert\Functions

Complexity

Total Complexity

17

Size/Duplication

Total Lines	66
Duplicated Lines	0 %

Test Coverage

Coverage

67.57%

Importance

Changes	2
Bugs	0	Features	1

6 Methods

Rating	Name	Duplication	Size	Complexity
A	assertScalar()	0	4	2
B	assertValidCallable()	0	23	7
A	isStrigableObject()	0	3	2
A	throwNotApplicableCallableException()	0	8	1
A	assertStringable()	0	5	3
A	assertType()	0	4	2

<?php
declare(strict_types=1);

namespace Seboettg\Collection\Assert;

use ReflectionException;
use ReflectionFunction;
use Seboettg\Collection\Assert\Exception\NotApplicableCallableException;
use Seboettg\Collection\Assert\Exception\NotConvertibleToStringException;
use Seboettg\Collection\Assert\Exception\TypeIsNotAScalarException;
use Seboettg\Collection\Assert\Exception\WrongTypeException;
use function is_scalar;
use function is_object;
use function method_exists;

final class Functions
{
    public static final function assertScalar($value, string $message): void

As per PSR2, final should precede the visibility keyword.

    {
        if (!is_scalar($value)) {
            throw new TypeIsNotAScalarException($message);
        }
    }

    public static final function assertType($value, string $fqcn, string $message)

As per PSR2, final should precede the visibility keyword.

    {
        if (!$value instanceof $fqcn) {
            throw new WrongTypeException($message);
        }
    }

    public static final function assertStringable($value, string $message)

As per PSR2, final should precede the visibility keyword.

    {
        if (!is_scalar($value)) {
            if (!self::isStrigableObject($value)) {
                throw new NotConvertibleToStringException($message);
            }
        }
    }

    private static function isStrigableObject($value): bool
    {
        return is_object($value) && method_exists($value, "__toString");
    }

    public static function assertValidCallable(callable $callable, array $parameters)
    {
        $reflected = new ReflectionFunction($callable);
        if (count($reflected->getParameters()) !== count($parameters)) {
            throw new NotApplicableCallableException(
                "The number of parameters of the given callable does not match the expected number."
            );
        }
        for ($i = 0; $i < count($reflected->getParameters()); ++$i) {

It seems like you are calling the size function count() as part of the test condition. You might want to compute the size beforehand, and not on each iteration.

            $reflectedParamType = $reflected->getParameters()[$i]->getType()->getName();

The method getName() does not exist on ReflectionType. It seems like you code against a sub-type of ReflectionType such as ReflectionNamedType.

            $expectedParam = $parameters[$i];
            switch ($expectedParam) {
                case "scalar":
                    if (!in_array($reflectedParamType, ["int", "string", "bool", "float"])) {
                        self::throwNotApplicableCallableException($i, "scalar", $reflectedParamType);
                    }
                    break;
                case "mixed":
                    //ignore, since every type is allowed
                    break;
                default:
                    if ($reflectedParamType !== $expectedParam) {
                        self::throwNotApplicableCallableException($i, $expectedParam, $reflectedParamType);
                    }
            }
        }
    }

    private static function throwNotApplicableCallableException($paramNumber, $expectedType, $actualType)
    {
        throw new NotApplicableCallableException(
            sprintf(
                "Parameter %d of type %s does not match the expected type of %s",
                $paramNumber,
                $actualType,
                $expectedType
            )
        );
    }
}

/**
 * @param $value
 * @param string $message description that will be included in the failure message if the assertion fails.
 * @return void
 */
function assertScalar($value, string $message): void
{
    Functions::assertScalar($value, $message);
}

/**
 * @param $value
 * @param string $fqcn full qualified class name
 * @param string $message description that will be included in the failure message if the assertion fails.
 * @return void
 */
function assertType($value, string $fqcn, string $message): void
{
    Functions::assertType($value, $fqcn, $message);
}

/**
 * @param $value
 * @param string $message description that will be included in the failure message if the assertion fails.
 * @return void
 */
function assertStringable($value, string $message): void
{
    Functions::assertStringable($value, $message);
}


function assertValidCallable(callable $callable, array $parameters)
{
    Functions::assertValidCallable($callable, $parameters);
}