larapie / actions

src/Concerns/ResolvesMethodDependencies.php

<?php

namespace Larapie\Actions\Concerns;

use Illuminate\Database\Eloquent\ModelNotFoundException;
use Illuminate\Support\Facades\Validator;
use Illuminate\Support\Str;
use Illuminate\Validation\ValidationException;
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 runningAs() must be provided by classes using this trait. How about adding it as abstract method to this trait?

It seems like getAttributesFromRoute() 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.

    }
}