allejo\stakx\Website

Complexity

Total Complexity

44

Size/Duplication

Total Lines	432
Duplicated Lines	4.63 %

Coupling/Cohesion

Components	1
Dependencies	22

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
B	build()	0	77	5
B	watch()	0	30	1
B	watchListenerFunction()	0	38	6
A	getConfiguration()	0	4	1
A	isConfLess()	0	4	1
A	setConfLess()	0	4	1
C	creationWatcher()	10	62	10
C	modificationWatcher()	10	55	10
A	deletionWatcher()	0	3	1
A	createFolderStructure()	0	17	3
B	configureHighlighter()	0	28	4

<?php

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

namespace allejo\stakx;

use allejo\stakx\Command\BuildableCommand;
use allejo\stakx\Core\StakxLogger;
use allejo\stakx\Event\BuildProcessComplete;
use allejo\stakx\Exception\FileAwareException;
use allejo\stakx\Filesystem\FileExplorer;
use allejo\stakx\Filesystem\FilesystemLoader as fs;
use allejo\stakx\Filesystem\Folder;
use allejo\stakx\Manager\AssetManager;
use allejo\stakx\Manager\CollectionManager;
use allejo\stakx\Manager\DataManager;
use allejo\stakx\Manager\PageManager;
use allejo\stakx\Manager\ThemeManager;
use allejo\stakx\Manager\TwigManager;
use Highlight\Highlighter;
use Kwf\FileWatcher\Event\AbstractEvent;
use Kwf\FileWatcher\Event\Create;
use Kwf\FileWatcher\Event\Modify;
use Kwf\FileWatcher\Event\Move;
use Kwf\FileWatcher\Watcher;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\EventDispatcher\EventDispatcher;

class Website
{
    /**
     * The location of where the compiled website will be written to.
     *
     * @var Folder
     */
    private $outputDirectory;

    /**
     * When set to true, the Stakx website will be built without a configuration file.
     *
     * @var bool
     */
    private $confLess;

    /**
     * @var StakxLogger
     */
    private $output;

    /**
     * @var AssetManager
     */
    private $am;

Avoid variables with short names like $am. Configured minimum length is 3.

    /**
     * @var CollectionManager
     */
    private $cm;

Avoid variables with short names like $cm. Configured minimum length is 3.

    /**
     * @var DataManager
     */
    private $dm;

Avoid variables with short names like $dm. Configured minimum length is 3.

    /**
     * @var PageManager
     */
    private $pm;

Avoid variables with short names like $pm. Configured minimum length is 3.

    /**
     * @var ThemeManager
     */
    private $tm;

Avoid variables with short names like $tm. Configured minimum length is 3.

    /** @var Compiler */
    private $compiler;

    /** @var array */
    private $creationQueue;

    private $container;

    /**
     * Constructor.
     */
    public function __construct(ContainerInterface $container)
    {
        $this->container = $container;

        $this->creationQueue = [];
        $this->output = $container->get('logger');
    }

    /**
     * Compile the website.
     *
     * @param bool $tracking Whether or not to keep track of files as they're compiled to save time in 'watch'
     */
    public function build($tracking = false)
    {
        $logger = $this->container->get('logger');
        $conf = $this->container->get(Configuration::class);

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

            return false;
        }

        Service::setParameter(BuildableCommand::WATCHING, $tracking);

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

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

        $templateEngine = $this->container->get('templating');

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

        $this->compiler = $this->container->get('compiler');
        $this->compiler->setTargetFolder($this->outputDirectory);
        $this->compiler->setThemeName($theme);
        $this->compiler->compileAll();

        if (Service::getParameter(BuildableCommand::BUILD_PROFILE))
        {
            if (!$templateEngine->hasProfiler())
            {
                $logger->writeln('This template engine currently does not support a profiler.');
            }
            else
            {
                $profilerText = $templateEngine->getProfilerOutput($this->compiler);
                $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 (!is_null($theme))
        {
            $logger->notice("Looking for '${theme}' theme...");

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

        //
        // Static file management
        //
        $this->am = $this->container->get(AssetManager::class);
        $this->am->configureFinder($this->getConfiguration()->getIncludes(), $assetsToIgnore);
        $this->am->setFolder($this->outputDirectory);
        $this->am->copyFiles();

        /** @var EventDispatcher $dispatcher */
        $dispatcher = $this->container->get('event_dispatcher');
        $dispatcher->dispatch(BuildProcessComplete::NAME, new BuildProcessComplete());
    }

    public function watch()
    {
        $this->output->writeln('Building website...');
        $this->build(true);
        $this->output->writeln(sprintf('Watching %s', getcwd()));

        $exclusions = array_merge($this->getConfiguration()->getExcludes(), [
            $this->getConfiguration()->getTargetFolder(),
        ]);
        $fileExplorer = FileExplorer::create(
            getcwd(), $exclusions, $this->getConfiguration()->getIncludes()
        );

        $newWatcher = Watcher::create(getcwd());
        $newWatcher
            ->setLogger($this->output)
            ->setEventDispatcher($this->container->get('event_dispatcher'))
            ->setExcludePatterns(array_merge(
                $exclusions, FileExplorer::$vcsPatterns, [Configuration::CACHE_FOLDER]
            ))
            ->setIterator($fileExplorer->getExplorer())
//            ->addListener(Create::NAME, function ($e) { $this->watchListenerFunction($e); })

62% of this comment could be valid code. Did you maybe forget this after debugging?

//            ->addListener(Modify::NAME, function ($e) { $this->watchListenerFunction($e); })
//            ->addListener(Move::NAME,   function ($e) { $this->watchListenerFunction($e); })
        ;

        $this->output->writeln('Watch started successfully');

        $newWatcher->start();
    }

    private function watchListenerFunction(AbstractEvent $event)

This method is not used, and could be removed.

    {
        $filePath = fs::getRelativePath($event->filename);

        try
        {
            switch ($event::getEventName())
            {
                case Create::NAME:
                    $this->creationWatcher($filePath);
                    break;

                case Modify::NAME:
                    $this->modificationWatcher($filePath);
                    break;

                case Move::NAME:
                    $newFile = fs::getRelativePath($event->destFilename);

The property destFilename does not seem to exist. Did you mean filename?

                    $this->deletionWatcher($filePath);

The call to the method allejo\stakx\Website::deletionWatcher() seems un-needed as the method has no side-effects.

                    $this->creationWatcher($newFile);
                    break;
            }
        }
        catch (FileAwareException $e)
        {
            $this->output->writeln(sprintf("Your website failed to build with the following error in file '%s': %s",
                $e->getPath(),
                $e->getMessage()
            ));
        }
        catch (\Exception $e)
        {
            $this->output->writeln(sprintf('Your website failed to build with the following error: %s',
                $e->getMessage()
            ));
        }
    }

    /**
     * @return Configuration
     */
    public function getConfiguration()
    {
        return $this->container->get(Configuration::class);
    }

    /**
     * Get whether or not the website is being built in Configuration-less mode.
     *
     * @return bool True when being built with no configuration file
     */
    public function isConfLess()
    {
        return $this->confLess;
    }

    /**
     * Set whether or not the website should be built with a configuration.
     *
     * @param bool $status True when a website should be built without a configuration
     */
    public function setConfLess($status)
    {
        $this->confLess = $status;
    }

    /**
     * @param string $filePath
     * @param mixed  $newlyCreate
     */
    private function creationWatcher($filePath, $newlyCreate = true)
    {
        if ($newlyCreate)
        {
            $this->output->writeln(sprintf('File creation detected: %s', $filePath));
        }

        if ($this->pm->shouldBeTracked($filePath))
        {
            try
            {
                $pageView = $this->pm->createNewItem($filePath);

                $this->compiler->compilePageView($pageView);

                unset($this->creationQueue[$filePath]);
            }
            catch (\Exception $e)
            {
                $this->creationQueue[$filePath] = true;
            }
        }
        elseif ($this->cm->shouldBeTracked($filePath))
        {
            try
            {
                $contentItem = $this->cm->createNewItem($filePath);
                TwigManager::getInstance()->addGlobal('collections', $this->cm->getCollections());

                $this->pm->trackNewContentItem($contentItem);

$contentItem of type object<allejo\stakx\Document\ReadableDocument> is not a sub-type of object<allejo\stakx\Document\ContentItem>. It seems like you assume a child class of the class allejo\stakx\Document\ReadableDocument to be always present.

                $this->compiler->compileContentItem($contentItem);

The method allejo\stakx\Compiler::compileContentItem() has been deprecated.

                $this->compiler->compileSome([
                    'namespace' => 'collections',
                    'dependency' => $contentItem->getNamespace(),
                ]);

                unset($this->creationQueue[$filePath]);
            }
            catch (\Exception $e)
            {
                $this->creationQueue[$filePath] = true;
            }
        }
        elseif ($this->dm->shouldBeTracked($filePath))

This code seems to be duplicated across your project.

        {
            $change = $this->dm->createNewItem($filePath);
            TwigManager::getInstance()->addGlobal('data', $this->dm->getDataItems());

            $this->compiler->compileSome([
                'namespace' => 'data',
                'dependency' => $change,
            ]);
        }
        elseif (!is_null($this->tm) && $this->tm->shouldBeTracked($filePath))
        {
            $this->tm->createNewItem($filePath);
        }
        elseif ($this->am->shouldBeTracked($filePath))
        {
            $this->am->createNewItem($filePath);
        }
    }

    /**
     * @param string $filePath
     */
    private function modificationWatcher($filePath)
    {
        $this->container->get('logger')->writeln(sprintf('File change detected: %s', $filePath));

        if (isset($this->creationQueue[$filePath]))
        {
            $this->creationWatcher($filePath, false);
        }
        elseif ($this->compiler->isParentTemplate($filePath))
        {
            TwigManager::getInstance()->clearTemplateCache();

The method Twig_Environment::clearTemplateCache() has been deprecated with message: since 1.18.3 (to be removed in 2.0)

            $this->compiler->refreshParent($filePath);
        }
        elseif ($this->compiler->isImportDependency($filePath))
        {
            TwigManager::getInstance()->clearTemplateCache();

The method Twig_Environment::clearTemplateCache() has been deprecated with message: since 1.18.3 (to be removed in 2.0)

            $this->compiler->compileImportDependencies($filePath);
        }
        elseif ($this->pm->isTracked($filePath))
        {
            $change = $this->pm->refreshItem($filePath);

            TwigManager::getInstance()->clearTemplateCache();

The method Twig_Environment::clearTemplateCache() has been deprecated with message: since 1.18.3 (to be removed in 2.0)

            $this->compiler->compilePageView($change);
        }
        elseif ($this->cm->isTracked($filePath))
        {
            $contentItem = &$this->cm->getContentItem($filePath);
            $contentItem->readContent();

            $this->compiler->compileContentItem($contentItem);

The method allejo\stakx\Compiler::compileContentItem() has been deprecated.

            $this->compiler->compileSome([
                'namespace' => 'collections',
                'dependency' => $contentItem->getNamespace(),
            ]);
        }
        elseif ($this->dm->isTracked($filePath))

This code seems to be duplicated across your project.

        {
            $change = $this->dm->refreshItem($filePath);
            TwigManager::getInstance()->addGlobal('data', $this->dm->getDataItems());

            $this->compiler->compileSome([
                'namespace' => 'data',
                'dependency' => $change,
            ]);
        }
        elseif (!is_null($this->tm) && $this->tm->isTracked($filePath))
        {
            $this->tm->refreshItem($filePath);
        }
        elseif ($this->am->isTracked($filePath))
        {
            $this->am->refreshItem($filePath);
        }
    }

    /**
     * @param string $filePath
     */
    private function deletionWatcher($filePath)

The parameter $filePath is not used and could be removed.

    {
    }

    /**
     * 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::getParameter(BuildableCommand::NO_CLEAN))
        {
            fs::remove($targetDir);

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

        }

        if (!Service::getParameter(BuildableCommand::USE_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 = Service::setParameter(Configuration::HIGHLIGHTER_ENABLED, $this->getConfiguration()->isHighlighterEnabled());

        if (!$enabled)
        {
            return;
        }

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

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

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