View::newAttributeInstance() - Code Metrics - Inspection of "Add view attributes" - coniadev/chuck - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — main ( f41f09...08852a )

by Thomas
created 2023-01-11 19:02 UTC
View::newAttributeInstance() A

↳ Parent: View
Complexity

Conditions	3
Paths	4
Size

Total Lines	16
Code Lines	9
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	9
CRAP Score	3
Importance

Changes
Metric	Value
eloc	9
c	0
b	0
f	0
dl	0
loc	16
ccs	9
cts	9
cp	1
rs	9.9666
cc	3
nc	4
nop	1
crap	3
<?php

declare(strict_types=1);

namespace Conia\Chuck;

use Closure;
use Conia\Chuck\Attribute\Render;
use Conia\Chuck\Exception\ContainerException;
use Conia\Chuck\Exception\HttpServerError;
use Conia\Chuck\Exception\RuntimeException;
use Conia\Chuck\Registry\Registry;
use Conia\Chuck\Registry\Resolver;
use Conia\Chuck\Renderer\Config as RendererConfig;
use Conia\Chuck\Renderer\Renderer;
use Conia\Chuck\Request;
use Conia\Chuck\Response;
use Conia\Chuck\ResponseFactory;
use Conia\Chuck\Routing\Route;
use Conia\Chuck\ViewAttributeInterface;
use JsonException;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\StreamFactoryInterface;
use ReflectionAttribute;
use ReflectionClass;
use ReflectionFunction;
use ReflectionFunctionAbstract;
use ReflectionMethod;
use ReflectionObject;
use Stringable;
use Throwable;

class View
{
    protected ?array $attributes = null;
    protected Closure $closure;

    public function __construct(
        callable|string|array $view,
        protected readonly array $routeArgs,
        protected readonly Registry $registry
    ) {
        if (is_callable($view)) {
            /** @var callable $view -- Psalm complains even though we use is_callable() */
            $this->closure = Closure::fromCallable($view);
        } else {
            $this->closure = $this->getClosure($view);
        }
    }

    public function execute(): mixed
    {
        return ($this->closure)(...$this->getArgs(
            self::getReflectionFunction($this->closure)
        ));
    }

    public function respond(
        Request $request,
        Route $route,
        Registry $registry,
    ): Response {
        /**
         * @psalm-suppress MixedAssignment
         *
         * Later in the function we check the type of $result.
         */
        $result = $this->execute();

        if ($result instanceof Response) {
            return $result;
        }

        if ($result instanceof ResponseInterface) {
            $sf = $registry->get(StreamFactoryInterface::class);
            assert($sf instanceof StreamFactoryInterface);

            return new Response($result, $sf);
        }

        $rendererConfig = $route->getRenderer();

        if ($rendererConfig) {
            return $this->respondFromRenderer($request, $registry, $rendererConfig, $result);
        }

        $renderAttributes = $this->attributes(Render::class);

        if (count($renderAttributes) > 0) {
            assert($renderAttributes[0] instanceof Render);

            return $renderAttributes[0]->response($request, $registry, $result);
        }

        $responseFactory = new ResponseFactory($registry);

        if (is_string($result)) {
            return $responseFactory->html($result);
        }
        if ($result instanceof Stringable) {
            return $responseFactory->html($result->__toString());
        }

        try {
            return $responseFactory->json($result);
        } catch (JsonException) {
            throw new RuntimeException('Cannot determine a response handler for the return type of the view');
        }
    }

    public static function getReflectionFunction(
        callable $callable
    ): ReflectionFunction|ReflectionMethod {
        if ($callable instanceof Closure) {
            return new ReflectionFunction($callable);
        }
        if (is_object($callable)) {
            return (new ReflectionObject($callable))->getMethod('__invoke');
        }
        /** @var Closure|non-falsy-string $callable */
        return new ReflectionFunction($callable);
    }

    /** @psalm-param $filter ?class-string */
    public function attributes(string $filter = null): array
    {
        $reflector = new ReflectionFunction($this->closure);

        if (!isset($this->attributes)) {
            $this->attributes = array_map(function ($attribute) {
                return $this->newAttributeInstance($attribute);
            }, $reflector->getAttributes());
        }

        if ($filter) {
            return array_filter($this->attributes, function ($attribute) use ($filter) {
            return array_filter(/** @scrutinizer ignore-type */ $this->attributes, function ($attribute) use ($filter) {
                return $attribute instanceof $filter;
            });
        }

        return $this->attributes;

    }

    protected function newAttributeInstance(ReflectionAttribute $attribute): object
    {
        $taggedRegistry = $this->registry->tag(ViewAttributeInterface::class);
        $attrName = $attribute->getName();

        if ($taggedRegistry->has($attrName)) {
            $instance = $taggedRegistry->new($attrName, ...$attribute->getArguments());
        } else {
            $instance = $attribute->newInstance();
        }

        if ($instance instanceof ViewAttributeInterface) {
            $instance->injectRegistry($this->registry);
        }

        return $instance;
    }

    protected function respondFromRenderer(
        Request $request,
        Registry $registry,
        RendererConfig $rendererConfig,
        mixed $result,
    ): Response {
        $entry = $registry->tag(Renderer::class)->entry($rendererConfig->type);
        $class = $entry->definition();
        $options = $entry->getArgs();

        if ($options instanceof Closure) {
            /** @var mixed */
            $options = $options();
        }

        assert(is_string($class));
        assert(is_subclass_of($class, Renderer::class));
        $renderer = new $class($request, $registry, $rendererConfig->args, $options);

        return $renderer->response($result);
    }

    protected function getClosure(array|string $view): Closure
    {
        if (is_array($view)) {

            [$controllerName, $method] = $view;
            assert(is_string($controllerName));
            assert(is_string($method));
        } else {
            if (!str_contains($view, '::')) {
                $view .= '::__invoke';
            }

            [$controllerName, $method] = explode('::', $view);
        }

        if (class_exists($controllerName)) {
            $rc = new ReflectionClass($controllerName);
            $constructor = $rc->getConstructor();
            $args = $constructor ? $this->getArgs($constructor) : [];
            $controller = $rc->newInstance(...$args);

            if (method_exists($controller, $method)) {
                return Closure::fromCallable([$controller, $method]);
            }
            $view = $controllerName . '::' . $method;

            throw HttpServerError::withSubTitle("Controller method not found {$view}");
        }

        throw HttpServerError::withSubTitle("Controller not found {$controllerName}");
    }

    /**
     * Determines the arguments passed to the view and/or controller constructor.
     *
     * - If a view parameter implements Request, the request will be passed.
     * - If names of the view parameters match names of the route arguments
     *   it will try to convert the argument to the parameter type and add it to
     *   the returned args list.
     * - If the parameter is typed, try to resolve it via registry or
     *   autowiring.
     * - Otherwise fail.
     *
     * @psalm-suppress MixedAssignment -- $args values are mixed
     */
    protected function getArgs(ReflectionFunctionAbstract $rf): array
    {
        /** @var array<string, mixed> */
        $args = [];
        $params = $rf->getParameters();
        $errMsg = 'View parameters cannot be resolved. Details: ';

        foreach ($params as $param) {
            $name = $param->getName();

            try {
                $args[$name] = match ((string)$param->getType()) {
                    'int' => is_numeric($this->routeArgs[$name]) ?
                        (int)$this->routeArgs[$name] :
                        throw new RuntimeException($errMsg . "Cannot cast '{$name}' to int"),
                    'float' => is_numeric($this->routeArgs[$name]) ?
                        (float)$this->routeArgs[$name] :
                        throw new RuntimeException($errMsg . "Cannot cast '{$name}' to float"),
                    'string' => $this->routeArgs[$name],
                    default => (new Resolver($this->registry))->resolveParam($param),
                };
            } catch (ContainerException $e) {
                throw $e;
            } catch (Throwable $e) {
                // Check if the view parameter has a default value
                if (!array_key_exists($name, $this->routeArgs) && $param->isDefaultValueAvailable()) {
                    $args[$name] = $param->getDefaultValue();

                    continue;
                }

                throw new RuntimeException($errMsg . $e->getMessage());
            }
        }

        assert(count($params) === count($args));

        return $args;
    }
}

coniadev / chuck

Push — main ( f41f09...08852a )

View::newAttributeInstance() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
