MichaelRubel\EnhancedContainer\Traits\HelpsProxies

Complexity

Total Complexity

18

Size/Duplication

Total Lines	153
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	25
Bugs	1	Features	1

9 Methods

Rating	Name	Duplication	Size	Complexity
A	getContextualConcrete()	0	3	1
A	getClassForResolution()	0	5	3
A	resolvePassedClass()	0	6	1
A	getDependencies()	0	19	5
A	getPassedParameters()	0	9	3
A	getBindingConcrete()	0	7	1
A	convertToNamespace()	0	5	2
A	sliceParameters()	0	3	1
A	makeContainerParameters()	0	6	1

<?php

declare(strict_types=1);

namespace MichaelRubel\EnhancedContainer\Traits;

use Illuminate\Support\Arr;

trait HelpsProxies
{
    /**
     * @param string      $class
     * @param array       $dependencies
     * @param string|null $context
     *
     * @return object
     */
    public function resolvePassedClass(string $class, array $dependencies = [], ?string $context = null): object
    {
        $class        = $this->getClassForResolution($class, $context);
        $dependencies = $this->getDependencies($class, $dependencies);

        return resolve($class, $dependencies);
    }

    /**
     * Get the class for resolution.
     *
     * @param string      $class
     * @param string|null $context
     *
     * @return string
     */
    public function getClassForResolution(string $class, ?string $context = null): string
    {
        return ! is_null($context) && isset(app()->contextual[$context])
            ? $this->getContextualConcrete($class, $context)
            : $class;
    }

    /**
     * Try to get the contextual concrete.
     *
     * @param string      $class
     * @param string|null $context
     *
     * @return string
     */
    public function getContextualConcrete(string $class, ?string $context = null): string
    {
        return app()->contextual[$context][$class] ?? $class;
    }

    /**
     * Try to get binding concrete.
     *
     * @param string $class
     *
     * @return string
     * @throws \ReflectionException
     */
    public function getBindingConcrete(string $class): string
    {
        return (
           new \ReflectionFunction(
               app()->getBindings()[$class]['concrete']
           )
        )->getStaticVariables()['concrete'];
    }

    /**
     * Resolve class dependencies.
     *
     * @param string $class
     * @param array  $dependencies
     *
     * @return array
     * @throws \ReflectionException
     */
    public function getDependencies(string $class, array $dependencies = []): array
    {
        if (! empty($dependencies) && ! Arr::isAssoc($dependencies)) {
            if (! class_exists($class)) {
                $class = $this->getBindingConcrete($class);
            }

            /** @var class-string $class */
            $constructor = (new \ReflectionClass($class))->getConstructor();

            if ($constructor) {
                $dependencies = $this->makeContainerParameters(
                    $constructor->getParameters(),
                    $dependencies
                );
            }
        }

        return $dependencies;
    }

    /**
     * @param object $class
     * @param string $method
     * @param array  $parameters
     *
     * @return array
     * @throws \ReflectionException
     */
    public function getPassedParameters(object $class, string $method, array $parameters): array
    {
        if (empty($parameters) || Arr::isAssoc($parameters)) {
            return $parameters;
        }

        return $this->makeContainerParameters(
            (new \ReflectionMethod($class, $method))->getParameters(),
            $parameters
        );
    }

    /**
     * Combine parameters to make it container-readable.
     *
     * @param array $reflectionParameters
     * @param array $methodParameters
     *
     * @return array
     */
    public function makeContainerParameters(array $reflectionParameters, array $methodParameters): array
    {
        return collect($this->sliceParameters($reflectionParameters, $methodParameters))

$this->sliceParameters($reflectionParameters, $methodParameters) of type array is incompatible with the type Illuminate\Contracts\Support\Arrayable expected by parameter $value of collect().

            ->map->getName()
            ->combine($this->sliceParameters($methodParameters, $reflectionParameters))
            ->all();
    }

    /**
     * Slice an array to align the parameters.
     *
     * @param array $parameters
     * @param array $countable
     *
     * @return array
     */
    public function sliceParameters(array $parameters, array $countable): array
    {
        return array_slice($parameters, 0, count($countable));
    }

    /**
     * Convert the object to its namespace.
     *
     * @param object|string $object
     *
     * @return string
     */
    public function convertToNamespace(object|string $object): string
    {
        return is_string($object)
            ? $object
            : $object::class;
    }
}