Dgame\Object\Validator

Complexity

Total Complexity

23

Size/Duplication

Total Lines	132
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	3

Test Coverage

Coverage

62.16%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	new()	0	4	1
A	isValidSetterMethod()	0	20	5
A	isValidParameterValue()	0	4	2
A	isValidGetterMethod()	0	16	5
A	areValidMethodArguments()	0	12	3
A	validateMethodArguments()	0	19	6

<?php

namespace Dgame\Object;

use Dgame\Type\TypeFactory;
use ReflectionMethod;
use ReflectionParameter;
use Throwable;

/**
 * Class Validator
 * @package Dgame\Object
 */
final class Validator
{
    /**
     * @var ObjectFacade
     */
    private $facade;

    /**
     * Validator constructor.
     *
     * @param ObjectFacade $facade
     */
    public function __construct(ObjectFacade $facade)
    {
        $this->facade = $facade;
    }

    /**
     * @param ObjectFacade $facade
     *
     * @return Validator

Should the return type not be \self?

     */
    public static function new(ObjectFacade $facade): self
    {
        return new self($facade);
    }

    /**
     * @param ReflectionMethod $method
     * @param mixed            $value
     *
     * @return bool
     */
    public function isValidSetterMethod(ReflectionMethod $method, $value): bool
    {
        if (!$method->isPublic()) {
            return false;
        }

        if ($method->getNumberOfParameters() === 0) {
            return true;
        }

        if ($method->getNumberOfRequiredParameters() > 1) {
            return false;
        }

        if ($value === null) {
            return $method->getParameters()[0]->allowsNull();
        }

        return $this->isValidParameterValue($method->getParameters()[0], $value);
    }

    /**
     * @param ReflectionParameter $parameter
     * @param mixed               $value
     *
     * @return bool
     */
    public function isValidParameterValue(ReflectionParameter $parameter, $value): bool
    {
        return !$parameter->hasType() || TypeFactory::reflection($parameter)->accept($value);
    }

    /**
     * @param ReflectionMethod $method
     *
     * @return bool
     */
    public function isValidGetterMethod(ReflectionMethod $method): bool
    {
        if (!$method->isPublic()) {
            return false;
        }

        try {
            $value = $method->invoke($this->facade->getObject());
        } catch (Throwable $t) {
            return false;
        }

        $returnType = $method->getReturnType();

        return $value !== null || $returnType === null || $returnType->allowsNull();
    }

    /**
     * @param ReflectionMethod $method
     * @param array            ...$args
     *
     * @return bool
     */

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

    public function areValidMethodArguments(ReflectionMethod $method, ...$args): bool
    {
        if (!$method->isPublic()) {
            return false;
        }

        if (count($args) < $method->getNumberOfRequiredParameters()) {
            return false;
        }

        return $this->validateMethodArguments($method, ...$args);
    }

    /**
     * @param ReflectionMethod $method
     * @param array            ...$args
     *
     * @return bool
     */

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

    private function validateMethodArguments(ReflectionMethod $method, ...$args): bool
    {
        $parameters = $method->getParameters();
        foreach ($args as $i => $arg) {
            if (!array_key_exists($i, $parameters)) {
                break;
            }

            if ($arg === null && !$parameters[$i]->allowsNull()) {
                return false;
            }

            if (!$this->isValidParameterValue($parameters[$i], $arg)) {
                return false;
            }
        }

        return true;
    }
}