Hgraca\Helper\InstanceHelper

Complexity

Total Complexity

14

Size/Duplication

Total Lines	99
Duplicated Lines	34.34 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	getReflectionProperties()	0	4	1
A	createInstance()	0	6	1
A	createInstanceWithoutConstructor()	0	6	1
A	setProtectedProperty()	8	8	1
A	getProtectedProperty()	9	9	1
A	getParameters()	17	17	4
B	getCallableReflectionMethod()	0	17	5

<?php

namespace Hgraca\Helper;

use Closure;
use Hgraca\Helper\Concept\ReflectionHelperAbstract;
use InvalidArgumentException;
use ReflectionException;
use ReflectionFunction;
use ReflectionMethod;
use ReflectionProperty;

final class InstanceHelper extends ReflectionHelperAbstract
{
    /**
     * @param mixed $object
     *
     * @return ReflectionProperty[]
     */
    public static function getReflectionProperties($object): array
    {
        return ClassHelper::getReflectionProperties(get_class($object));
    }

    /**
     * @return mixed
     */
    public static function createInstance(string $fqcn, array $constructorArguments = [])
    {
        $reflectionClass = self::getReflectionClass($fqcn);

        return $reflectionClass->newInstanceArgs($constructorArguments);
    }

    /**
     * @return mixed
     */
    public static function createInstanceWithoutConstructor(string $fqcn)
    {
        $reflectionClass = self::getReflectionClass($fqcn);

        return $reflectionClass->newInstanceWithoutConstructor();
    }

    public static function setProtectedProperty($object, string $propertyName, $value)

This method seems to be duplicated in your project.

    {
        $class = self::getReflectionClass(get_class($object));

        $property = ClassHelper::getReflectionProperty($class, $propertyName);
        $property->setAccessible(true);
        $property->setValue($object, $value);
    }

    public static function getProtectedProperty($object, string $propertyName)

This method seems to be duplicated in your project.

    {
        $class = self::getReflectionClass(get_class($object));

        $property = ClassHelper::getReflectionProperty($class, $propertyName);
        $property->setAccessible(true);

        return $property->getValue($object);
    }

    /**
     * @param callable $input Can be a callable array (method defaults to '__construct'), callable object or Closure
     *
     * @throws InvalidArgumentException
     *
     * @return array [index => [name, class]]
     */
    public static function getParameters($input): array

This method seems to be duplicated in your project.

    {
        try {
            $reflectionMethod = self::getCallableReflectionMethod($input);
        } catch (ReflectionException $e) {
            return [];
        }

        foreach ($reflectionMethod->getParameters() as $index => $param) {
            $reflectionParameters[$index]['name'] = $param->getName();

$reflectionParameters was never initialized. Although not strictly required by PHP, it is generally a good practice to add $reflectionParameters = array(); before regardless.

            if (null !== $param->getClass()) {
                $reflectionParameters[$index]['class'] = $param->getClass()->name;
            }
        }

        return $reflectionParameters ?? [];
    }

    /**
     * @throws InvalidArgumentException
     *
     * @return ReflectionFunction|ReflectionMethod
     */
    private static function getCallableReflectionMethod($input)
    {
        if (is_array($input)) {
            $dependentClass  = is_string($input[0]) ? $input[0] : get_class($input[0]);
            $dependentMethod = $input[1] ?? '__construct';

            return new ReflectionMethod($dependentClass, $dependentMethod);
        } elseif ($input instanceof Closure) {

            return new ReflectionFunction($input);
        } elseif (is_callable($input)) {

            return new ReflectionMethod(get_class($input), '__invoke');
        } else {
            throw new InvalidArgumentException('$input needs to be a callable');
        }
    }
}