Hgraca\Helper\InstanceHelper

Complexity

Total Complexity

12

Size/Duplication

Total Lines	82
Duplicated Lines	28.05 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes

0

6 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
C	getParameters()	6	23	7

<?php

namespace Hgraca\Helper;

use Closure;
use Hgraca\Helper\Concept\ReflectionHelperAbstract;
use InvalidArgumentException;
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
    {
        if (is_array($input)) {
            $dependentClass  = is_string($input[0]) ? $input[0] : get_class($input[0]);
            $dependentMethod = $input[1] ?? '__construct';
            $reflectionMethod = new ReflectionMethod($dependentClass, $dependentMethod);
        } elseif ($input instanceof Closure) {
            $reflectionMethod = new ReflectionFunction($input);
        } elseif (is_callable($input)) {
            $reflectionMethod = new ReflectionMethod(get_class($input), '__invoke');
        } else {
            throw new InvalidArgumentException('$input needs to be a callable');
        }

        foreach ($reflectionMethod->getParameters() as $index => $param) {

This code seems to be duplicated across your project.

            $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 ?? [];
    }
}