Spiral\Views\ViewManager

Complexity

Total Complexity

22

Size/Duplication

Total Lines	179
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	18	4
A	reset()	0	12	3
A	render()	0	3	1
A	get()	0	13	4
A	addDependency()	0	3	1
A	getContext()	0	3	1
A	findEngine()	0	9	3
A	getEngines()	0	3	1
A	compile()	0	13	3
A	addEngine()	0	9	1

<?php

/**
 * Spiral Framework.
 *
 * @license   MIT
 * @author    Anton Titov (Wolfy-J)
 */

declare(strict_types=1);

namespace Spiral\Views;

use Spiral\Core\FactoryInterface;
use Spiral\Views\Config\ViewsConfig;
use Spiral\Views\Exception\ViewException;

final class ViewManager implements ViewsInterface
{
    /** @var ViewsConfig */
    private $config;

    /** @var ViewContext */
    private $context;

    /** @var LoaderInterface */
    private $loader;

    /** @var ViewCache|null */
    private $cache;

    /** @var EngineInterface[] */
    private $engines;

    /**
     * @param ViewsConfig      $config
     * @param FactoryInterface $factory
     */
    public function __construct(ViewsConfig $config, FactoryInterface $factory)
    {
        $this->config = $config;
        $this->context = new ViewContext();
        $this->loader = $factory->make(ViewLoader::class, [
            'namespaces' => $config->getNamespaces()
        ]);

        foreach ($this->config->getDependencies() as $dependency) {
            $this->addDependency($dependency->resolve($factory));
        }

        foreach ($this->config->getEngines() as $engine) {
            $this->addEngine($engine->resolve($factory));
        }

        if ($this->config->isCacheEnabled()) {
            $this->cache = new ViewCache();
        }
    }

    /**
     * Attach new view context dependency.
     *
     * @param DependencyInterface $dependency
     */
    public function addDependency(DependencyInterface $dependency): void
    {
        $this->context = $this->context->withDependency($dependency);
    }

    /**
     * @return ContextInterface
     */
    public function getContext(): ContextInterface
    {
        return $this->context;
    }

    /**
     * Attach new view engine.
     *
     * @param EngineInterface $engine
     */
    public function addEngine(EngineInterface $engine): void
    {
        $this->engines[] = $engine->withLoader($this->loader);

        uasort($this->engines, function (EngineInterface $a, EngineInterface $b) {
            return strcmp($a->getLoader()->getExtension(), $b->getLoader()->getExtension());
        });

        $this->engines = array_values($this->engines);
    }

    /**
     * Get all associated view engines.
     *
     * @return EngineInterface[]
     */
    public function getEngines(): array
    {
        return $this->engines;
    }

    /**
     * Compile one of multiple cache versions for a given view path.
     *
     * @param string $path
     *
     * @throws ViewException
     */
    public function compile(string $path): void
    {
        if ($this->cache !== null) {
            $this->cache->resetPath($path);
        }

        $engine = $this->findEngine($path);

        // Rotate all possible context variants and warm up cache
        $generator = new ContextGenerator($this->context);
        foreach ($generator->generate() as $context) {
            $engine->reset($path, $context);
            $engine->compile($path, $context);
        }
    }

    /**
     * Reset view cache for a given path. Identical to compile method by effect but faster.
     *
     * @param string $path
     */
    public function reset(string $path): void
    {
        if ($this->cache !== null) {
            $this->cache->resetPath($path);
        }

        $engine = $this->findEngine($path);

        // Rotate all possible context variants and warm up cache
        $generator = new ContextGenerator($this->context);
        foreach ($generator->generate() as $context) {
            $engine->reset($path, $context);
        }
    }

    /**
     * Get view from one of the associated engines.
     *
     * @param string $path
     * @return ViewInterface
     *
     * @throws ViewException
     */
    public function get(string $path): ViewInterface
    {
        if ($this->cache !== null && $this->cache->has($this->context, $path)) {
            return $this->cache->get($this->context, $path);
        }

        $view = $this->findEngine($path)->get($path, $this->context);

        if ($this->cache !== null) {
            $this->cache->set($this->context, $path, $view);
        }

        return $view;
    }

    /**
     * @param string $path
     * @param array  $data
     * @return string
     *
     * @throws ViewException
     */
    public function render(string $path, array $data = []): string
    {
        return $this->get($path)->render($data);
    }

    /**
     * @param string $path
     * @return EngineInterface
     *
     * @throws ViewException
     */
    protected function findEngine(string $path): EngineInterface
    {
        foreach ($this->engines as $engine) {
            if ($engine->getLoader()->exists($path)) {
                return $engine;
            }
        }

        throw new ViewException("Unable to detect view engine for `{$path}`.");
    }
}