Website::__construct() - Code Metrics - Inspection of "Move Manager classes to container instead" - stakx-io/stakx - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 80d5dd...e32bbf )

by Vladimir
created 2017-11-02 08:33 UTC
Website::__construct() A

↳ Parent: Website
Complexity

Conditions	1
Paths	1
Size

Total Lines	9
Code Lines	6
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
dl	0
loc	9
rs	9.6666
c	0
b	0
f	0
cc	1
eloc	6
nc	1
nop	1
<?php

/**
 * @copyright 2017 Vladimir Jimenez
 * @license   https://github.com/allejo/stakx/blob/master/LICENSE.md MIT
 */

namespace allejo\stakx;

use allejo\stakx\Command\BuildableCommand;
use allejo\stakx\Core\StakxLogger;
use allejo\stakx\Exception\FileAwareException;
use allejo\stakx\Manager\AssetManager;
use allejo\stakx\Manager\CollectionManager;
use allejo\stakx\Manager\DataManager;
use allejo\stakx\Manager\MenuManager;
use allejo\stakx\Manager\PageManager;
use allejo\stakx\Manager\ThemeManager;
use allejo\stakx\Manager\TwigManager;
use allejo\stakx\Filesystem\FileExplorer;
use allejo\stakx\System\Filesystem;
use allejo\stakx\Filesystem\Folder;
use allejo\stakx\Twig\StakxTwigTextProfiler;
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;

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

    /**
     * The main configuration to be used to build the specified website.
     *
     * @var Configuration
     */
    private $configuration;

    /**
     * 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;


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


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


    /**
     * @var Filesystem
     */
    private $fs;


    /** @var MenuManager */
    private $mm;


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


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


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

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

    private $container;

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

        $this->creationQueue = array();
        $this->output = $container->get('logger');
        $this->mm = new MenuManager();
        $this->fs = new Filesystem();
    }

    /**
     * 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)
    {
        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());

        $this->handleDataItems();
        $this->handleCollections();

        // Handle PageViews
        $this->pm = $this->container->get(PageManager::class);
        $this->pm->parsePageViews($this->getConfiguration()->getPageViewFolders());

        // Handle the site's menu
        $this->mm->setLogger($this->output);
        $this->mm->buildFromPageViews($this->pm->getStaticPageViews());

        // Configure our Twig environment
        $twigGlobals = [
            [
                'name' => 'data',
                'value' => ($this->container->has(DataManager::class)) ?
                    $this->container->get(DataManager::class)->getJailedDataItems() : []
            ],
            [
                'name' => 'collections',
                'value' => ($this->container->has(CollectionManager::class)) ?
                    $this->container->get(CollectionManager::class)->getJailedCollections() : []
            ]
        ];

        $twigEnv = new TwigManager();
        $twigEnv->configureTwig($this->getConfiguration(), array(
            'safe'    => Service::getParameter(BuildableCommand::SAFE_MODE),
            'globals' => array_merge(array(
                array('name' => 'site', 'value' => $this->getConfiguration()->getConfiguration()),
                array('name' => 'menu', 'value' => $this->mm->getSiteMenu()),
                array('name' => 'pages', 'value' => $this->pm->getJailedStaticPageViews()),
            ), $twigGlobals),
        ));

        $profiler = null;

        if (Service::getParameter(BuildableCommand::BUILD_PROFILE))
        {
            $profiler = new \Twig_Profiler_Profile();
            TwigManager::getInstance()->addExtension(new \Twig_Extension_Profiler($profiler));
        }

        // Compile everything
        $theme = $this->configuration->getTheme();
        $this->compiler = new Compiler();
        $this->compiler->setLogger($this->output);
        $this->compiler->setRedirectTemplate($this->getConfiguration()->getRedirectTemplate());
        $this->compiler->setPageViews($this->pm->getPageViews(), $this->pm->getPageViewsFlattened());

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

        if (Service::getParameter(BuildableCommand::BUILD_PROFILE))
        {
            $dumper = new StakxTwigTextProfiler();
            $dumper->setTemplateMappings($this->compiler->getTemplateMappings());
            $text = $dumper->dump($profiler);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
            $this->output->writeln($text);
        }

        // 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))
        {
            $this->output->notice("Looking for '${theme}' theme...");

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

        //
        // Static file management
        //
        $this->am = new AssetManager();
        $this->am->configureFinder($this->getConfiguration()->getIncludes(), $assetsToIgnore);
        $this->am->setLogger($this->output);
        $this->am->setFolder($this->outputDirectory);
        $this->am->copyFiles();
    }

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

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

        $newWatcher = Watcher::create(getcwd());
        $newWatcher
            ->setLogger($this->output)
            ->setExcludePatterns(array_merge(
                $exclusions, FileExplorer::$vcsPatterns, array(Configuration::CACHE_FOLDER)
            ))
            ->setIterator($fileExplorer->getExplorer())
            ->addListener(Create::NAME, function ($e) { $this->watchListenerFunction($e); })
            ->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)
    {
        $filePath = $this->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 = $this->fs->getRelativePath($event->destFilename);


                    $this->deletionWatcher($filePath);
class User
{
    private $email;

    public function getEmail()
    {
        return $this->email;
    }

    public function setEmail($email)
    {
        $this->email = $email;
    }
}
                    $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->configuration;
    }

    /**
     * @param string $configFile
     *
     * @throws \LogicException
     */
    public function setConfiguration($configFile)
    {
        if (!$this->fs->exists($configFile) && !$this->isConfLess())
        {
            $this->output->error('You are trying to build a website in a directory without a configuration file. Is this what you meant to do?');
            $this->output->error("To build a website without a configuration, use the '--no-conf' option");

            throw new \LogicException('Cannot build a website without a configuration when not in Configuration-less mode');
        }

        if ($this->isConfLess())
        {
            $configFile = '';

        }

        $this->configuration = new Configuration();
        $this->configuration->setLogger($this->output);
        $this->configuration->parse($configFile);

        Service::setParameter('build.preserveCase', $this->configuration->getConfiguration()['build']['preserveCase']);
    }

    /**
     * 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
     */
    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);

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

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

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

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

            $this->compiler->compileSome(array(
                '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->output->writeln(sprintf('File change detected: %s', $filePath));

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

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

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

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

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

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

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

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

            $this->compiler->compileSome(array(
                '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)

    {
    }

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

        if (!Service::getParameter(BuildableCommand::NO_CLEAN))
        {
            $this->fs->remove($targetDir);
        }

        if (!Service::getParameter(BuildableCommand::USE_CACHE))
        {
            $this->fs->remove($this->fs->absolutePath(Configuration::CACHE_FOLDER, 'twig'));
            $this->fs->mkdir($this->fs->absolutePath($this->fs->appendPath(Configuration::CACHE_FOLDER, 'twig')));
        }

        $this->fs->mkdir($targetDir);
    }

    private function configureHighlighter()
    {
        // Configure our highlighter
        Service::setParameter(Configuration::HIGHLIGHTER_ENABLED, $this->getConfiguration()->isHighlighterEnabled());

        if (Service::getParameter(Configuration::HIGHLIGHTER_ENABLED))
        {
            foreach ($this->getConfiguration()->getHighlighterCustomLanguages() as $lang => $path)
            {
                $fullPath = $this->fs->absolutePath($path);

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

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

    ///
    // Build Process
    ///

    private function handleDataItems()
    {
        $pm = $this->container->get(PageManager::class);


        if (!$this->getConfiguration()->hasDataItems())
        {
            $this->container->get('logger')->notice('No DataItem folders or Datasets registered... Ignoring');

            $this->pm->setDatasets([]);

            return;
        }

        $dm = $this->container->get(DataManager::class);

        $dm->parseDataItems($this->getConfiguration()->getDataFolders());
        $dm->parseDataSets($this->getConfiguration()->getDataSets());

        $pm->setDatasets($dm->getDataItems());
    }

    private function handleCollections()
    {
        $pm = $this->container->get(PageManager::class);


        if (!$this->getConfiguration()->hasCollections())
        {
            $this->container->get('logger')->notice('No Collections registered... Ignoring');

            $emptyCollections = [];
            $pm->setCollections($emptyCollections);

            return;
        }

        $cm = $this->container->get(CollectionManager::class);

        $cm->parseCollections($this->getConfiguration()->getCollectionsFolders());

        $pm->setCollections($cm->getCollections());
    }
}

1			<?php
2
3			/**
4			* @copyright 2017 Vladimir Jimenez
5			* @license https://github.com/allejo/stakx/blob/master/LICENSE.md MIT
6			*/
7
8			namespace allejo\stakx;
9
10			use allejo\stakx\Command\BuildableCommand;
11			use allejo\stakx\Core\StakxLogger;
12			use allejo\stakx\Exception\FileAwareException;
13			use allejo\stakx\Manager\AssetManager;
14			use allejo\stakx\Manager\CollectionManager;
15			use allejo\stakx\Manager\DataManager;
16			use allejo\stakx\Manager\MenuManager;
17			use allejo\stakx\Manager\PageManager;
18			use allejo\stakx\Manager\ThemeManager;
19			use allejo\stakx\Manager\TwigManager;
20			use allejo\stakx\Filesystem\FileExplorer;
21			use allejo\stakx\System\Filesystem;
22			use allejo\stakx\Filesystem\Folder;
23			use allejo\stakx\Twig\StakxTwigTextProfiler;
24			use Highlight\Highlighter;
25			use Kwf\FileWatcher\Event\AbstractEvent;
26			use Kwf\FileWatcher\Event\Create;
27			use Kwf\FileWatcher\Event\Modify;
28			use Kwf\FileWatcher\Event\Move;
29			use Kwf\FileWatcher\Watcher;
30			use Symfony\Component\DependencyInjection\ContainerInterface;
31
32			class Website
33			{
34			/**
35			* The location of where the compiled website will be written to.
36			*
37			* @var Folder
38			*/
39			private $outputDirectory;
40
stakx-io / stakx

Push — master ( 80d5dd...e32bbf )

Website::__construct() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
