DaveRandom\CallbackValidator\MatchTester::isMatch()

Complexity

Conditions	20
Paths	18

Size

Total Lines	72
Code Lines	32

Duplication

Lines	10
Ratio	13.89 %

Code Coverage

Tests	27
CRAP Score	21.5244

Importance

Changes

0

<?php declare(strict_types = 1);
    public static function isMatch($superTypeName, $superTypeNullable, $subTypeName, $subTypeNullable, $weak)
    {
        // If the super type is unspecified, anything is a match
        if ($superTypeName === null) {
            return true;
        }

        // If the sub type is unspecified, nothing is a match
        if ($subTypeName === null) {
            return false;
        }

        $superTypeName = (string)$superTypeName;

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

        $subTypeName = (string)$subTypeName;

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

        // Sub type cannot be nullable unless the super type is as well
        if ($subTypeNullable && !$superTypeNullable) {
            // nullable void doesn't really make sense but for completeness...
            return $superTypeName === BuiltInTypes::VOID && $subTypeName === BuiltInTypes::VOID;
        }

        // If the string is an exact match it's definitely acceptable
        if ($superTypeName === $subTypeName) {
            return true;
        }

        // Check iterable
        if ($superTypeName === BuiltInTypes::ITERABLE) {

This code seems to be duplicated across your project.

            return $subTypeName === BuiltInTypes::ARRAY
                || $subTypeName === \Traversable::class
                || \is_subclass_of($subTypeName, \Traversable::class);
        }

        // Check callable
        if ($superTypeName === BuiltInTypes::CALLABLE) {

This code seems to be duplicated across your project.

            return $subTypeName === \Closure::class
                || \method_exists($subTypeName, '__invoke')
                || \is_subclass_of($subTypeName, \Closure::class);
        }

        // If the super type is built-in, check whether casting rules can succeed
        if (isset(self::$builtInTypes[$superTypeName])) {
            // Fail immediately in strict mode
            if (!$weak) {
                return false;
            }

            // Nothing else satisfies array, callable, void or iterable
            if (!isset(self::$scalarTypes[$superTypeName])) {
                return false;
            }

            // Scalars can all cast to each other
            if (isset(self::$scalarTypes[$subTypeName])) {
                return true;
            }

            // Classes with __toString() satisfy string
            if ($superTypeName === BuiltInTypes::STRING && \method_exists($subTypeName, '__toString')) {

This if statement, and the following return statement can be replaced with return $superTypeName === \DaveRandom\CallbackValidator\BuiltInTypes::STRING && \method_exists($subTypeName, '__toString');.

                return true;
            }

            return false;
        }

        // We now know the super type is not built-in and there's no string match, sub type must not be built-in
        if (isset(self::$builtInTypes[$subTypeName])) {
            return false;
        }

        return \is_subclass_of($subTypeName, $superTypeName);
    }
}