Selami\Stdlib\Resolver

Complexity

Total Complexity

9

Size/Duplication

Total Lines	64
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	getParameterHints()	0	18	2
A	checkClassName()	0	8	2
A	checkMethodName()	0	8	2
A	getParamType()	0	12	3

<?php
declare(strict_types=1);

namespace Selami\Stdlib;

use ReflectionMethod;
use ReflectionParameter;
use Selami\Stdlib\Exception\InvalidArgumentException;
use ReflectionException;

class Resolver
{
    /**
     * @param string $className
     * @param string $methodName
     * @return array
     * @throws InvalidArgumentException
     */

    public static function getParameterHints(string $className, string $methodName) : array
    {

        self::checkClassName($className);
        self::checkMethodName($className, $methodName);

        $method = new ReflectionMethod($className, $methodName);
        /**
         * @var array $parameters
         */
        $parameters = $method->getParameters();
        $parameterHints = [];
        foreach ($parameters as $param) {
            $parameter = self::getParamType($param);
            $parameterHints[$parameter['name']] = $parameter['type'];
        }
        return $parameterHints;
    }

    private static function checkClassName(string $className) : void
    {
        if (! class_exists($className)) {
            throw new InvalidArgumentException(
                sprintf('%s class does not exist!', $className)
            );
        }
    }

    private static function checkMethodName(string $className, string $methodName) : void
    {
        if (! method_exists($className, $methodName)) {
            throw new InvalidArgumentException(
                sprintf('%s does not have method named %s!', $className, $methodName)
            );
        }
    }

    /**
     * @param ReflectionParameter $parameter
     * @return array
     * @throws InvalidArgumentException
     */
    private static function getParamType(ReflectionParameter $parameter) :array
    {
        $type = $parameter->getType();
        if ($type->isBuiltin()) {
            return ['name' => $parameter->name, 'type' => (string) $type];
        }
        try {
            return ['name' => $parameter->name, 'type' =>$parameter->getClass()->name];
        } catch (ReflectionException $e) {
            throw new InvalidArgumentException($e->getMessage());
        }
    }
}