HelpsProxies::isOrderable() - Code Metrics - Inspection of "extract logic to the individual method" - michael-rubel/laravel-enhanced-container - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( 27d456...a1f0d8 )

by Michael

created 2022-04-30 22:45 UTC

HelpsProxies::isOrderable() A

↳ Parent: HelpsProxies

Complexity

Conditions	3
Paths	3

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	3

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
cc	3
eloc	3
c	2
b	0
f	0
nc	3
nop	3
dl	0
loc	5
ccs	4
cts	4
cp	1
crap	3
rs	10

<?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;
    }

    /**
     * @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
    {
        $base = current($methodParameters);

        if ($this->isOrderable($base, $reflectionParameters, $methodParameters)) {
            return $base;
        }

        return collect($this->sliceParameters($reflectionParameters, $methodParameters))
        return collect(/** @scrutinizer ignore-type */ $this->sliceParameters($reflectionParameters, $methodParameters))
            ->map->getName()
            ->combine($this->sliceParameters($methodParameters, $reflectionParameters))
            ->all();
    }

    /**
     * Check if the container can handle the order of passed parameters.
     *
     * @param array $base
     * @param array $reflectionParameters
     * @param array $methodParameters
     *
     * @return bool
     */
    public function isOrderable(mixed $base, array $reflectionParameters, array $methodParameters): bool
    {
        return is_array($base)
            && Arr::isAssoc($base)
            && single($methodParameters) <=> single($reflectionParameters);
    }

    /**
     * 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;
    }
}


michael-rubel / laravel-enhanced-container

Push — main ( 27d456...a1f0d8 )

HelpsProxies::isOrderable() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like