allejo\stakx\EventSubscriber\AssetEngineSubscriber

Complexity

Total Complexity

14

Size/Duplication

Total Lines	124
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	15

Test Coverage

Coverage

82.46%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	processConfigurationSettings()	0	13	2
A	compileAssetEnginePageViews()	0	24	3
A	getSubscribedEvents()	0	8	1
A	buildCacheFolder()	0	15	1
B	processAssetEnginePageView()	0	46	6

<?php

/**
 * @copyright 2018 Vladimir Jimenez
 * @license   https://github.com/stakx-io/stakx/blob/master/LICENSE.md MIT
 */

namespace allejo\stakx\EventSubscriber;

use __\__;
use allejo\stakx\AssetEngine\AssetEngineInterface;
use allejo\stakx\AssetEngine\AssetEngineManager;
use allejo\stakx\Configuration;
use allejo\stakx\Document\StaticPageView;
use allejo\stakx\Event\CompilerPostRenderStaticPageView;
use allejo\stakx\Event\ConfigurationParseComplete;
use allejo\stakx\Event\PageManagerPostProcess;
use allejo\stakx\Filesystem\FileExplorer;
use allejo\stakx\Filesystem\FilesystemLoader as fs;
use allejo\stakx\Filesystem\FilesystemPath;
use allejo\stakx\Filesystem\Folder;
use allejo\stakx\RuntimeStatus;
use allejo\stakx\Service;
use Psr\Log\LoggerInterface;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;

class AssetEngineSubscriber implements EventSubscriberInterface
{
    private $assetEngineManager;
    private $assetPageViews;
    private $logger;

    public function __construct(AssetEngineManager $assetEngineManager, LoggerInterface $logger)
    {
        $this->assetEngineManager = $assetEngineManager;
        $this->assetPageViews = [];
        $this->logger = $logger;
    }

    public function processConfigurationSettings(ConfigurationParseComplete $event)
    {
        $configuration = $event->getConfiguration()->getConfiguration();

        /** @var AssetEngineInterface $engine */
        foreach ($this->assetEngineManager->getEngines() as $engine)
        {
            $defaults = __::get($configuration, $engine->getConfigurationNamespace(), []);
            $options = array_merge($engine->getDefaultConfiguration(), $defaults);

            $engine->setOptions($options);
        }
    }

    public function processAssetEnginePageView(PageManagerPostProcess $event)
    {
        /**
         * @var string               $folder
         * @var AssetEngineInterface $engine
         */
        foreach ($this->assetEngineManager->getFoldersToWatch() as $folder => $engine)
        {
            $assetFolder = fs::absolutePath($folder);

$folder is of type integer|string, but the function expects a object<string>.

            if (!fs::exists($assetFolder))
            {
                continue;
            }

            $engine->setPageManager($event->getPageManager());
            $extensions = [];

            foreach ($engine->getExtensions() as $extension)
            {
                $extensions[] = "/.{$extension}.twig$/";
            }

            $explorer = FileExplorer::create($assetFolder, [], $extensions, FileExplorer::INCLUDE_ONLY_FILES | FileExplorer::IGNORE_DIRECTORIES);

            foreach ($explorer as $file)
            {
                $assetPageView = new StaticPageView($file);

                try
                {
                    $event->getPageManager()->trackNewPageView($assetPageView);
                    $this->assetPageViews[$assetPageView->getRelativeFilePath()] = [
                        'engine' => $engine,
                    ];
                }
                catch (\Exception $e)
                {
                    $this->logger->error('An exception occurred while creating a Static PageView for an AssetEngine');
                    $this->logger->error('  {message}', [
                        'message' => $e->getMessage(),
                    ]);
                }
            }
        }
    }

    public function compileAssetEnginePageViews(CompilerPostRenderStaticPageView $event)
    {
        $pageView = $event->getPageView();
        $filePath = $pageView->getRelativeFilePath();

        if (isset($this->assetPageViews[$filePath]))
        {
            /** @var AssetEngineInterface $engine */
            $engine = $this->assetPageViews[$filePath]['engine'];
            $cacheDir = $this->buildCacheFolder($engine);

            if (Service::hasRunTimeFlag(RuntimeStatus::USING_CACHE))
            {
                $engine->loadCache($cacheDir);
            }

            $output = $engine->parse($event->getCompiledOutput(), [
                'pageview' => $pageView,
            ]);

            $engine->saveCache($cacheDir);
            $event->setCompiledOutput($output);
        }
    }

    public static function getSubscribedEvents()
    {
        return [
            ConfigurationParseComplete::NAME => 'processConfigurationSettings',
            PageManagerPostProcess::NAME => 'processAssetEnginePageView',
            CompilerPostRenderStaticPageView::NAME => 'compileAssetEnginePageViews',
        ];
    }

    private function buildCacheFolder(AssetEngineInterface $engine)
    {
        $cacheDirPath = new FilesystemPath(Service::getWorkingDirectory() . '/');
        $cacheDirPath
            ->appendToPath(Configuration::CACHE_FOLDER . '/')
            ->appendToPath(__::slug(strtolower($engine->getName())) . '/')
        ;

        fs::mkdir($cacheDirPath);

        $cacheDir = new Folder($cacheDirPath);
        $cacheDir->freeze();

        return $cacheDir;
    }
}