Larapie\Actions\Concerns\ResolvesMethodDependencies

Complexity

Total Complexity

22

Size/Duplication

Total Lines	93
Duplicated Lines	0 %

Test Coverage

Coverage

93.62%

Importance

Changes	1
Bugs	1	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	resolveContainerDependency()	0	20	4
A	resolveAndCall()	0	9	2
A	resolveMethodDependencies()	0	9	1
A	findAttributeFromParameter()	0	10	4
A	resolveDependency()	0	15	6
A	updateAttributeWithResolvedInstance()	0	7	3
A	resolveRouteBinding()	0	7	2

<?php

namespace Larapie\Actions\Concerns;

use Illuminate\Database\Eloquent\ModelNotFoundException;
use Illuminate\Support\Str;
use Illuminate\Validation\ValidationException;
use Illuminate\Support\Facades\Validator;
use Larapie\Actions\Exception\MethodDoesNotExistException;
use ReflectionMethod;
use ReflectionParameter;

trait ResolvesMethodDependencies
{
    protected function resolveAndCall($instance, $method, $extras = [])
    {
        if (!method_exists($instance, $method)) {
            throw new MethodDoesNotExistException("method $method not found on " . get_class($instance));
        }

        $parameters = $this->resolveMethodDependencies($instance, $method, $extras);

        return $instance->{$method}(...$parameters);
    }

    protected function resolveMethodDependencies($instance, $method, $extras = [])
    {
        $reflector = new ReflectionMethod($instance, $method);

        $handler = function ($parameter) use ($extras) {
            return $this->resolveDependency($parameter, $extras);
        };

        return array_map($handler, $reflector->getParameters());
    }

    protected function resolveDependency(ReflectionParameter $parameter, $extras = [])
    {
        [$key, $value] = $this->findAttributeFromParameter($parameter->name, $extras);
        $class = $parameter->getClass();

        if ($key && (!$class || $value instanceof $class->name)) {

$class is of type ReflectionClass, thus it always evaluated to true.

            return $value;
        }

        if ($class) {

$class is of type ReflectionClass, thus it always evaluated to true.

            return $this->resolveContainerDependency($class->name, $key, $value, $parameter->name);
        }

        if ($parameter->isDefaultValueAvailable()) {
            return $parameter->getDefaultValue();
        }
    }

    protected function resolveContainerDependency($class, $key, $value, ?string $parameterName = null)
    {
        $instance = app($class);

        if (method_exists($instance, 'resolveRouteBinding')) {

            if (!$key) {
                throw (new ValidationException(Validator::make([], [
                    $parameterName => 'required'
                ])))->redirectTo($this->getRedirectUrl());

It seems like getRedirectUrl() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            }

            $instance = $this->resolveRouteBinding($instance, $value);
        }

        if ($key) {
            $this->updateAttributeWithResolvedInstance($key, $instance);
        }

        return $instance;
    }

    protected function resolveRouteBinding($instance, $value)
    {
        if (!$model = $instance->resolveRouteBinding($value)) {
            throw (new ModelNotFoundException())->setModel(get_class($instance));
        }

        return $model;
    }

    protected function findAttributeFromParameter($name, $extras = [])
    {
        $routeAttributes = $this->runningAs('controller') ? $this->getAttributesFromRoute($this->request) : [];

It seems like getAttributesFromRoute() must be provided by classes using this trait. How about adding it as abstract method to this trait?

It seems like runningAs() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $attributes = array_merge($this->attributes, $routeAttributes, $extras);

        if (array_key_exists($name, $attributes)) {
            return [$name, $attributes[$name]];
        }
        if (array_key_exists($snakedName = Str::snake($name), $attributes)) {
            return [$snakedName, $attributes[$snakedName]];
        }
    }

    public function updateAttributeWithResolvedInstance($key, $instance)
    {
        if ($this->runningAs('controller') && $this->request->has($key)) {
            return;
        }

        return $this->attributes[$key] = $instance;

The property attributes does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

    }
}