allejo\stakx\Website

Complexity

Total Complexity

15

Size/Duplication

Total Lines	168
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	12

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	19	1
A	getCompiler()	0	4	1
B	build()	0	65	5
A	getConfiguration()	0	4	1
A	createFolderStructure()	0	17	3
A	configureHighlighter()	0	30	4

<?php

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

namespace allejo\stakx;

use allejo\stakx\Event\BuildProcessComplete;
use allejo\stakx\Filesystem\FilesystemLoader as fs;
use allejo\stakx\Filesystem\Folder;
use allejo\stakx\Manager\AssetManager;
use allejo\stakx\Manager\ThemeManager;
use allejo\stakx\Templating\TemplateBridgeInterface;
use Highlight\Highlighter;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;

class Website
{
    private $eventDispatcher;
    private $templateBridge;
    private $configuration;
    private $assetManager;
    private $compiler;
    private $logger;

    public function __construct(
        Compiler $compiler,
        Configuration $configuration,
        AssetManager $assetManager,
        TemplateBridgeInterface $templateBridge,
        EventDispatcherInterface $eventDispatcher,
        Logger $logger
    ) {
        $this->eventDispatcher = $eventDispatcher;
        $this->templateBridge = $templateBridge;
        $this->configuration = $configuration;
        $this->assetManager = $assetManager;
        $this->compiler = $compiler;
        $this->logger = $logger;

        Service::setOption('theme', $this->getConfiguration()->getTheme());

        $this->configureHighlighter();
    }

    public function getCompiler()
    {
        return $this->compiler;
    }

    /**
     * Compile the website.
     *
     * @return true if the website built successfully

Should the return type not be false|null?

     */
    public function build()
    {
        if (empty($this->getConfiguration()->getPageViewFolders()))
        {
            $this->logger->error('No PageViews were configured for this site. Check the `pageviews` key in your _config.yml.');

            return false;
        }

        // Configure the environment
        $this->createFolderStructure();

        // Our output directory
        $outputDirectory = new Folder($this->getConfiguration()->getTargetFolder());
        $outputDirectory->setTargetDirectory($this->getConfiguration()->getBaseUrl());

        // Compile everything
        $theme = $this->getConfiguration()->getTheme();

        $this->compiler->setTargetFolder($outputDirectory);
        $this->compiler->setThemeName($theme);
        $this->compiler->compileAll();

        if (Service::hasRunTimeFlag(RuntimeStatus::IN_PROFILE_MODE))
        {
            if (!$this->templateBridge->hasProfiler())
            {
                $this->logger->writeln('This template engine currently does not support a profiler.');
            }
            else
            {
                $profilerText = $this->templateBridge->getProfilerOutput($this->compiler);
                $this->logger->writeln($profilerText);
            }
        }

        // At this point, we are looking at static files to copy over meaning we need to ignore all of the files that
        // make up the source of a stakx website
        $assetsToIgnore = array_merge(
            Configuration::$stakxSourceFiles,
            $this->getConfiguration()->getExcludes()
        );

        //
        // Theme Management
        //
        if ($theme !== null)
        {
            $this->logger->notice("Looking for '${theme}' theme...");

            $tm = new ThemeManager($theme, $this->eventDispatcher, $this->logger);
            $tm->configureFinder($this->getConfiguration()->getIncludes(), $assetsToIgnore);
            $tm->setFolder($outputDirectory);
            $tm->copyFiles();
        }

        //
        // Static file management
        //
        $this->assetManager->configureFinder($this->getConfiguration()->getIncludes(), $assetsToIgnore);
        $this->assetManager->setFolder($outputDirectory);
        $this->assetManager->copyFiles();

        $this->eventDispatcher->dispatch(BuildProcessComplete::NAME, new BuildProcessComplete());
    }

    /**
     * @return Configuration
     */
    public function getConfiguration()
    {
        return $this->configuration;
    }

    /**
     * Prepare the Stakx environment by creating necessary cache folders.
     */
    private function createFolderStructure()
    {
        $targetDir = fs::absolutePath($this->getConfiguration()->getTargetFolder());

$this->getConfiguration()->getTargetFolder() is of type string, but the function expects a object<string>.

        if (!Service::hasRunTimeFlag(RuntimeStatus::BOOT_WITHOUT_CLEAN))
        {
            fs::remove($targetDir);

The method remove() does not exist on allejo\stakx\Filesystem\FilesystemLoader. Did you maybe mean removeExtension()?

        }

        if (!Service::hasRunTimeFlag(RuntimeStatus::USING_CACHE))
        {
            fs::remove(fs::absolutePath(Configuration::CACHE_FOLDER, 'twig'));

The call to FilesystemLoader::absolutePath() has too many arguments starting with 'twig'.

The method remove() does not exist on allejo\stakx\Filesystem\FilesystemLoader. Did you maybe mean removeExtension()?

            fs::mkdir(fs::absolutePath(fs::appendPath(Configuration::CACHE_FOLDER, 'twig')));
        }

        fs::mkdir($targetDir);
    }

    /**
     * Configure the Highlighter object for highlighting code blocks.
     */
    private function configureHighlighter()
    {
        $enabled = $this->getConfiguration()->isHighlighterEnabled();

        if (!$enabled)
        {
            return;
        }

        Service::setRuntimeFlag(RuntimeStatus::USING_HIGHLIGHTER);

        foreach ($this->getConfiguration()->getHighlighterCustomLanguages() as $lang => $path)
        {
            $fullPath = fs::absolutePath($path);

            if (!fs::exists($fullPath))
            {
                $this->logger->warning('The following language definition could not be found: {lang}', [
                    'lang' => $path,
                ]);
                continue;
            }

            Highlighter::registerLanguage($lang, $fullPath);
            $this->logger->debug('Loading custom language {lang} from {path}...', [
                'lang' => $lang,
                'path' => $path,
            ]);
        }
    }
}