ViewRenderer::getViewPath() - Code Metrics - Inspection of "Add parameters injections to ViewRenderer + minor..." - yiisoft/yii-demo - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#122)

unknown
created 2020-08-09 06:09 UTC
ViewRenderer::getViewPath() A

↳ Parent: ViewRenderer
Complexity

Conditions	2
Paths	2
Size

Total Lines	7
Code Lines	3
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	2
eloc	3
c	0
b	0
f	0
nc	2
nop	0
dl	0
loc	7
rs	10
<?php

declare(strict_types=1);

namespace App\ViewRenderer;

use Psr\Container\ContainerInterface;
use Psr\Http\Message\ResponseInterface;
use Yiisoft\Aliases\Aliases;
use Yiisoft\Strings\Inflector;
use Yiisoft\View\ViewContextInterface;
use Yiisoft\View\WebView;
use Yiisoft\DataResponse\DataResponseFactoryInterface;
use Yiisoft\Yii\Web\Middleware\Csrf;

final class ViewRenderer implements ViewContextInterface
{
    protected ?string $name = null;
    protected DataResponseFactoryInterface $responseFactory;

    private Aliases $aliases;
    private ContainerInterface $container;
    private WebView $view;
    private string $layout;
    private ?string $viewBasePath;
    private ?string $viewPath = null;

    private array $contentInjections;
    private array $layoutInjections;

    public function __construct(
        DataResponseFactoryInterface $responseFactory,
        Aliases $aliases,
        ContainerInterface $container,
        WebView $view,
        string $viewBasePath,
        string $layout,
        array $contentInjections = [],
        array $layoutInjections = []
    ) {
        $this->responseFactory = $responseFactory;
        $this->aliases = $aliases;
        $this->container = $container;
        $this->view = $view;
        $this->viewBasePath = $viewBasePath;
        $this->layout = $layout;
        $this->contentInjections = $contentInjections;
        $this->layoutInjections = $layoutInjections;
    }

    public function getViewPath(): string
    {
        if ($this->viewPath !== null) {
            return $this->viewPath;
        }

        return $this->aliases->get($this->viewBasePath) . '/' . $this->name;
        return $this->aliases->get(/** @scrutinizer ignore-type */ $this->viewBasePath) . '/' . $this->name;
    }

    public function render(string $view, array $parameters = []): ResponseInterface
    {
        $contentRenderer = fn() => $this->renderProxy($view, $parameters);

        return $this->responseFactory->createResponse($contentRenderer);
    }

    public function renderPartial(string $view, array $parameters = []): ResponseInterface
    {
        $content = $this->view->render($view, $parameters, $this);

        return $this->responseFactory->createResponse($content);
    }

    public function withController(object $controller): self
    {
        $new = clone $this;
        $new->name = static::getName($controller);

        return $new;
    }

    public function withControllerName(string $name): self
    {
        $new = clone $this;
        $new->name = $name;

        return $new;
    }

    public function withViewPath(string $viewPath): self
    {
        $new = clone $this;
        $new->viewPath = $viewPath;

        return $new;
    }

    public function withViewBasePath(string $viewBasePath): self
    {
        $new = clone $this;
        $new->viewBasePath = $viewBasePath;

        return $new;
    }

    public function withLayout(string $layout): self
    {
        $new = clone $this;
        $new->layout = $layout;

        return $new;
    }

    public function withExtraContentInjections(array $injections): self
    {
        $new = clone $this;
        $new->contentInjections = array_merge($this->contentInjections, $injections);
        return $new;
    }

    public function withCsrf(string $requestAttribute = Csrf::REQUEST_NAME): self
    {
        return $this->withExtraContentInjections([
            CsrfInjection::class => ['requestAttribute' => $requestAttribute],
        ]);
    }

    private function renderProxy(string $view, array $parameters = []): string
    {
        $parameters = $this->injectParameters($parameters, $this->contentInjections);
        $content = $this->view->render($view, $parameters, $this);

        $layout = $this->findLayoutFile($this->layout);
        if ($layout === null) {

            return $content;
        }

        $layoutParameters = $this->injectParameters(['content' => $content], $this->layoutInjections);

        return $this->view->renderFile(
            $layout,
            $layoutParameters,
            $this,
        );
    }

    private function injectParameters(array $parameters, array $injections): array
    {
        foreach ($this->getInjections($injections) as $injection) {
            $parameters = array_merge($parameters, $injection->getParams());
        }
        return $parameters;
    }

    /**
     * @param array $injections
     * @return InjectionInterface[]
     */
    private function getInjections(array $injections): array
    {
        $instances = [];
        foreach ($injections as $key => $injection) {
            if (is_string($injection)) {
                $injection = $this->container->get($injection);
            } elseif (is_array($injection) && is_string($key)) {
                $injection = $this->container->get($key)->withConfig($injection);
            }
            if (!$injection instanceof InjectionInterface) {
                throw new \RuntimeException('Injection should be instance of ViewParametersInjectionInterface.');
            }
            $instances[] = $injection;
        }
        return $instances;
    }

    private function findLayoutFile(?string $file): ?string
    {
        if ($file === null) {
            return null;
        }

        $file = $this->aliases->get($file);

        if (pathinfo($file, PATHINFO_EXTENSION) !== '') {
            return $file;
        }

        return $file . '.' . $this->view->getDefaultExtension();
    }

    /**
     * Returns the controller name. Name should be converted to "id" case.
     * Method returns classname without `controller` on the ending.
     * If namespace is not contain `controller` or `controllers`
     * then returns only classname without `controller` on the ending
     * else returns all subnamespaces from `controller` (or `controllers`) to the end
     *
     * @param object $controller
     * @return string
     * @example App\Controller\FooBar\BazController -> foo-bar/baz
     * @example App\Controllers\FooBar\BazController -> foo-bar/baz
     * @example Path\To\File\BlogController -> blog
     * @see Inflector::camel2id()
     */
    private static function getName(object $controller): string
    {
        static $cache = [];

        $class = get_class($controller);
        if (isset($cache[$class])) {
            return $cache[$class];
        }

        $regexp = '/((?<=controller\\\|s\\\)(?:[\w\\\]+)|(?:[a-z]+))controller/iuU';
        if (!preg_match($regexp, $class, $m) || empty($m[1])) {
            throw new \RuntimeException('Cannot detect controller name');
        }

        $inflector = new Inflector();
        $name = str_replace('\\', '/', $m[1]);
        $name = $inflector->camel2id($name);

        $cache[$class] = $name;
        return $name;
    }
}

yiisoft / yii-demo

Pull Request — master (#122)

ViewRenderer::getViewPath() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
