Compiler - Code Metrics - Inspection of "Update Changelog with latest changes" - stakx-io/stakx - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( 38da12...667cd2 )

by Vladimir

created 2020-01-02 03:36 UTC

Compiler A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	525
Duplicated Lines	7.43 %

Coupling/Cohesion

Components	1
Dependencies	29

Test Coverage

Coverage

69.77%

Importance

Changes

Metric	Value
dl	39
loc	525
rs	9.76
c	0
b	0
f	0
ccs	120
cts	172
cp	0.6977
wmc	33
lcom	1
cbo	29

20 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	30	1
A	setTargetFolder()	0	4	1
A	setThemeName()	0	4	1
A	getTemplateBridge()	0	4	1
A	getTemplateMappings()	0	4	1
A	renderStaticPageView()	0	6	1
A	renderDynamicPageView()	0	6	1
A	renderRepeaterPageView()	0	6	1
A	compileAll()	0	7	2
B	compilePageView()	0	39	5
A	compileStaticPageView()	0	8	1
A	compileDynamicPageView()	0	25	4
A	compileRepeaterPageView()	0	14	2
A	writeToFilesystem()	0	8	1
A	compileStandardRedirects()	0	26	2
A	compileExpandedRedirects()	0	34	3
A	buildRepeaterPageViewHTML()	0	24	1
A	buildDynamicPageViewHTML()	19	19	1
A	buildStaticPageViewHTML()	20	20	1
A	createTwigTemplate()	0	26	2

How to fix Duplicated Code

<?php

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

namespace allejo\stakx;

use allejo\stakx\Document\BasePageView;
use allejo\stakx\Document\CollectableItem;
use allejo\stakx\Document\DynamicPageView;
use allejo\stakx\Document\PermalinkDocument;
use allejo\stakx\Document\RepeaterPageView;
use allejo\stakx\Document\StaticPageView;
use allejo\stakx\Document\TemplateReadyDocument;
use allejo\stakx\Event\CompilerPostRenderDynamicPageView;
use allejo\stakx\Event\CompilerPostRenderRepeaterPageView;
use allejo\stakx\Event\CompilerPostRenderStaticPageView;
use allejo\stakx\Event\CompilerPreRenderDynamicPageView;
use allejo\stakx\Event\CompilerPreRenderRepeaterPageView;
use allejo\stakx\Event\CompilerPreRenderStaticPageView;
use allejo\stakx\Event\CompilerTemplateCreation;
use allejo\stakx\Event\RedirectPreOutput;
use allejo\stakx\Exception\FileAwareException;
use allejo\stakx\Filesystem\WritableFolder;
use allejo\stakx\FrontMatter\ExpandedValue;
use allejo\stakx\Manager\CollectionManager;
use allejo\stakx\Manager\DataManager;
use allejo\stakx\Manager\MenuManager;
use allejo\stakx\Manager\PageManager;
use allejo\stakx\Templating\TemplateBridgeInterface;
use allejo\stakx\Templating\TemplateErrorInterface;
use allejo\stakx\Templating\TemplateInterface;
use Psr\Log\LoggerInterface;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;

/**
 * This class takes care of rendering the Twig body of PageViews with the respective information and it also takes care
 * of writing the rendered Twig to the filesystem.
 *
 * @since 0.1.1
 */
class Compiler
{
    /** @var string|false */
    private $redirectTemplate;

    /**
     * All of the PageViews handled by this Compiler instance indexed by their file paths relative to the site root.
     *
     * ```
     * array['_pages/index.html.twig'] = &PageView;
     * ```
     *
     * @var BasePageView[]
     */
    private $pageViewsFlattened;

    /** @var string[] */
    private $templateMapping;

    /** @var WritableFolder */
    private $folder;

    /** @var string */
    private $theme;

    private $templateBridge;
    private $pageManager;
    private $eventDispatcher;
    private $configuration;
    private $logger;

    public function __construct(
        TemplateBridgeInterface $templateBridge,
        Configuration $configuration,
        CollectionManager $collectionManager,
        DataManager $dataManager,
        MenuManager $menuManager,
        PageManager $pageManager,
        RedirectMapper $redirectMapper,
        EventDispatcherInterface $eventDispatcher,
        LoggerInterface $logger
    ) {
        $this->templateBridge = $templateBridge;
        $this->theme = '';
        $this->pageManager = $pageManager;
        $this->eventDispatcher = $eventDispatcher;
        $this->logger = $logger;
        $this->configuration = $configuration;

        $this->pageViewsFlattened = &$pageManager->getPageViewsFlattened();
        $this->redirectTemplate = $this->configuration->getRedirectTemplate();

        // Global variables maintained by stakx
        $this->templateBridge->setGlobalVariable('site', $configuration->getConfiguration());
        $this->templateBridge->setGlobalVariable('data', $dataManager->getJailedDataItems());
        $this->templateBridge->setGlobalVariable('collections', $collectionManager->getJailedCollections());
        $this->templateBridge->setGlobalVariable('menu', $menuManager->getSiteMenu());
        $this->templateBridge->setGlobalVariable('pages', $pageManager->getJailedStaticPageViews());
        $this->templateBridge->setGlobalVariable('repeaters', $pageManager->getJailedRepeaterPageViews());
        $this->templateBridge->setGlobalVariable('redirects', $redirectMapper->getRedirects());
    }

    /**
     * @param WritableFolder $folder
     */
    public function setTargetFolder(WritableFolder $folder)
    {
        $this->folder = $folder;
    }

    /**
     * @param string $themeName
     */
    public function setThemeName($themeName)
    {
        $this->theme = $themeName;
    }

    ///
    // Twig parent templates
    ///

    public function getTemplateBridge()
    {
        return $this->templateBridge;
    }

    public function getTemplateMappings()
    {
        return $this->templateMapping;
    }

    ///
    // Rendering HTML Functionality
    ///

    /**
     * Get the HTML for a Static PageView.
     *
     * This function just **renders** the HTML but does not write it to the filesystem. Use `compilePageView()` for that
     * instead.
     *
     * @param StaticPageView $pageView
     *
     * @throws TemplateErrorInterface
     *
     * @return string the HTML for a Static PageView
     */
    public function renderStaticPageView(StaticPageView $pageView)
    {
        $pageView->compile();

        return $this->buildStaticPageViewHTML($pageView);
    }

    /**
     * Get the HTML for a Dynamic PageView and ContentItem.
     *
     * This function just **renders** the HTML but does not write it to the filesystem. Use `compileDynamicPageView()`
     * for that instead.
     *
     * @param DynamicPageView       $pageView
     * @param TemplateReadyDocument $contentItem
     *
     * @throws TemplateErrorInterface
     *
     * @return string
     */
    public function renderDynamicPageView(DynamicPageView $pageView, TemplateReadyDocument $contentItem)
    {
        $template = $this->createTwigTemplate($pageView);

        return $this->buildDynamicPageViewHTML($template, $contentItem);
    }

    /**
     * Get the HTML for a Repeater PageView.
     *
     * @param RepeaterPageView $pageView
     * @param ExpandedValue    $expandedValue
     *
     * @throws TemplateErrorInterface
     *
     * @return string
     */
    public function renderRepeaterPageView(RepeaterPageView $pageView, ExpandedValue $expandedValue)
    {
        $template = $this->createTwigTemplate($pageView);

        return $this->buildRepeaterPageViewHTML($template, $pageView, $expandedValue);

    }

    ///
    // IO Functionality
    ///

    /**
     * Compile all of the PageViews registered with the compiler.
     *
     * @since 0.1.0
     */
    public function compileAll()
    {
        foreach ($this->pageViewsFlattened as &$pageView)
        {
            $this->compilePageView($pageView);
        }
    }

    /**
     * Compile an individual PageView item.
     *
     * This function will take care of determining *how* to treat the PageView and write the compiled output to a the
     * respective target file.
     *
     * @param DynamicPageView|RepeaterPageView|StaticPageView $pageView The PageView that needs to be compiled

     *
     * @since 0.1.1
     */
    public function compilePageView(BasePageView &$pageView)
    {
        Service::setOption('currentTemplate', $pageView->getAbsoluteFilePath());
        $this->logger->debug('Compiling {type} PageView: {pageview}', [
            'pageview' => $pageView->getRelativeFilePath(),
            'type' => $pageView->getType(),
        ]);

        try
        {
            switch ($pageView->getType())
            {
                case BasePageView::STATIC_TYPE:
                    $this->compileStaticPageView($pageView);

                    $this->compileStandardRedirects($pageView);
                    break;

                case BasePageView::DYNAMIC_TYPE:
                    $this->compileDynamicPageView($pageView);

                    $this->compileStandardRedirects($pageView);
                    break;

                case BasePageView::REPEATER_TYPE:
                    $this->compileRepeaterPageView($pageView);

                    $this->compileExpandedRedirects($pageView);
                    break;
            }
        }
        catch (TemplateErrorInterface $e)
        {
            throw new FileAwareException(
                $e->getMessage(),
                $e->getCode(),
                $e,
                $pageView->getRelativeFilePath(),
                $e->getTemplateLine() + $pageView->getLineOffset()
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
            );
        }
    }

    /**
     * Write the compiled output for a static PageView.
     *
     * @since 0.1.1
     *
     * @throws TemplateErrorInterface
     */
    private function compileStaticPageView(StaticPageView &$pageView)
    {
        $this->writeToFilesystem(
            $pageView->getTargetFile(),
            $this->renderStaticPageView($pageView),
            BasePageView::STATIC_TYPE
        );
    }

    /**
     * Write the compiled output for a dynamic PageView.
     *
     * @param DynamicPageView $pageView
     *
     * @since 0.1.1
     *
     * @throws TemplateErrorInterface
     */
    private function compileDynamicPageView(DynamicPageView &$pageView)
    {
        $contentItems = $pageView->getCollectableItems();
        $template = $this->createTwigTemplate($pageView);

        foreach ($contentItems as &$contentItem)
        {
            if ($contentItem->isDraft() && !Service::hasRunTimeFlag(RuntimeStatus::USING_DRAFTS))
            {
                $this->logger->debug('{file}: marked as a draft', [
                    'file' => $contentItem->getRelativeFilePath(),
                ]);

                continue;
            }

            $this->writeToFilesystem(
                $contentItem->getTargetFile(),
                $this->buildDynamicPageViewHTML($template, $contentItem),
                BasePageView::DYNAMIC_TYPE
            );

            $this->compileStandardRedirects($contentItem);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }
    }

    /**
     * Write the compiled output for a repeater PageView.
     *
     * @param RepeaterPageView $pageView
     *
     * @since 0.1.1
     *
     * @throws TemplateErrorInterface
     */
    private function compileRepeaterPageView(RepeaterPageView &$pageView)
    {
        $template = $this->createTwigTemplate($pageView);
        $permalinks = $pageView->getRepeaterPermalinks();
abstract class User
{
    /** @return string */
    abstract public function getPassword();
}

class MyUser extends User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}

        foreach ($permalinks as $permalink)
        {
            $this->writeToFilesystem(
                $pageView->getTargetFile($permalink->getEvaluated()),
                $this->buildRepeaterPageViewHTML($template, $pageView, $permalink),

                BasePageView::REPEATER_TYPE
            );
        }
    }

    /**
     * Write the given $output to the $targetFile as a $fileType PageView.
     *
     * @param string $targetFile
     * @param string $output
     * @param string $fileType
     */
    private function writeToFilesystem($targetFile, $output, $fileType)
    {
        $this->logger->notice('Writing {type} PageView file: {file}', [
            'type' => $fileType,
            'file' => $targetFile,
        ]);
        $this->folder->writeFile($targetFile, $output);
    }

    ///
    // Redirect handling
    ///

    /**
     * Write redirects for standard redirects.
     *
     * @throws TemplateErrorInterface
     *
     * @since 0.1.1
     */
    private function compileStandardRedirects(PermalinkDocument &$pageView)
    {
        $redirects = $pageView->getRedirects();

        foreach ($redirects as $redirect)
        {
            $redirectPageView = BasePageView::createRedirect(
                $redirect,
                $pageView->getPermalink(),
                $this->redirectTemplate
            );
            $redirectPageView->evaluateFrontMatter([], [
                'site' => $this->configuration->getConfiguration(),
            ]);

            $redirectEvent = new RedirectPreOutput(
                $redirect,
                $pageView->getPermalink(),
                $pageView,

                $redirectPageView
            );
            $this->eventDispatcher->dispatch(RedirectPreOutput::NAME, $redirectEvent);

            $this->compileStaticPageView($redirectPageView);
        }
    }

    /**
     * Write redirects for expanded redirects.
     *
     * @param RepeaterPageView $pageView
     *
     * @since 0.1.1
     */
    private function compileExpandedRedirects(RepeaterPageView &$pageView)
    {
        $permalinks = $pageView->getRepeaterPermalinks();

        /** @var ExpandedValue[] $repeaterRedirect */
        foreach ($pageView->getRepeaterRedirects() as $repeaterRedirect)
        {
            /**
             * @var int
             * @var ExpandedValue $redirect
             */
            foreach ($repeaterRedirect as $index => $redirect)
            {
                $redirectPageView = BasePageView::createRedirect(
                    $redirect->getEvaluated(),
                    $permalinks[$index]->getEvaluated(),
                    $this->redirectTemplate
                );
                $redirectPageView->evaluateFrontMatter([], [
                    'site' => $this->configuration->getConfiguration(),
                ]);

                $redirectEvent = new RedirectPreOutput(
                    $redirect->getEvaluated(),
                    $permalinks[$index]->getEvaluated(),
                    $pageView,
                    $redirectPageView
                );
                $this->eventDispatcher->dispatch(RedirectPreOutput::NAME, $redirectEvent);

                $this->compilePageView($redirectPageView);
            }
        }
    }

    ///
    // Twig Functionality
    ///

    /**
     * Get the compiled HTML for a specific iteration of a repeater PageView.
     *
     * @param TemplateInterface $template
     * @param RepeaterPageView  $pageView
     * @param ExpandedValue     $expandedValue
     *
     * @since  0.1.1
     *
     * @return string
     */
    private function buildRepeaterPageViewHTML(TemplateInterface &$template, RepeaterPageView &$pageView, ExpandedValue &$expandedValue)
    {
        $defaultContext = [
            'this' => $pageView->createJail(),
        ];

        $pageView->evaluateFrontMatter([
            'permalink' => $expandedValue->getEvaluated(),
            'iterators' => $expandedValue->getIterators(),
        ]);

        $preEvent = new CompilerPreRenderRepeaterPageView($pageView, $expandedValue);
        $this->eventDispatcher->dispatch(CompilerPreRenderRepeaterPageView::NAME, $preEvent);

        $context = array_merge($preEvent->getCustomVariables(), $defaultContext);
        $output = $template
            ->render($context)
        ;

        $postEvent = new CompilerPostRenderRepeaterPageView($pageView, $expandedValue, $output);
        $this->eventDispatcher->dispatch(CompilerPostRenderRepeaterPageView::NAME, $postEvent);

        return $postEvent->getCompiledOutput();
    }

    /**
     * Get the compiled HTML for a specific ContentItem.
     *
     * @param CollectableItem|TemplateReadyDocument $twigItem
     *
     * @since  0.1.1
     *
     * @return string
     */
    private function buildDynamicPageViewHTML(TemplateInterface &$template, &$twigItem)

    {
        $defaultContext = [
            'this' => $twigItem->createJail(),
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        ];

        $preEvent = new CompilerPreRenderDynamicPageView($twigItem);

        $this->eventDispatcher->dispatch(CompilerPreRenderDynamicPageView::NAME, $preEvent);

        $context = array_merge($preEvent->getCustomVariables(), $defaultContext);
        $output = $template
            ->render($context)
        ;

        $postEvent = new CompilerPostRenderDynamicPageView($twigItem, $output);

        $this->eventDispatcher->dispatch(CompilerPostRenderDynamicPageView::NAME, $postEvent);

        return $postEvent->getCompiledOutput();
    }

    /**
     * Get the compiled HTML for a static PageView.
     *
     * @since  0.1.1
     *
     * @throws TemplateErrorInterface
     *
     * @return string
     */
    private function buildStaticPageViewHTML(StaticPageView &$pageView)

    {
        $defaultContext = [
            'this' => $pageView->createJail(),
        ];

        $preEvent = new CompilerPreRenderStaticPageView($pageView);
        $this->eventDispatcher->dispatch(CompilerPreRenderStaticPageView::NAME, $preEvent);

        $context = array_merge($preEvent->getCustomVariables(), $defaultContext);
        $output = $this
            ->createTwigTemplate($pageView)
            ->render($context)
        ;

        $postEvent = new CompilerPostRenderStaticPageView($pageView, $output);

        $this->eventDispatcher->dispatch(CompilerPostRenderStaticPageView::NAME, $postEvent);

        return $postEvent->getCompiledOutput();
    }

    /**
     * Create a Twig template that just needs an array to render.
     *
     * @since  0.1.1
     *
     * @throws TemplateErrorInterface
     *
     * @return TemplateInterface
     */
    private function createTwigTemplate(BasePageView &$pageView)
    {
        try
        {
            $template = $this->templateBridge->createTemplate($pageView->getContent());

            $this->templateMapping[$template->getTemplateName()] = $pageView->getRelativeFilePath();

            $event = new CompilerTemplateCreation($pageView, $template, $this->theme);
            $this->eventDispatcher->dispatch(CompilerTemplateCreation::NAME, $event);

            return $template;
        }
        catch (TemplateErrorInterface $e)
        {
            $e
                ->setTemplateLine($e->getTemplateLine() + $pageView->getLineOffset())
                ->setContent($pageView->getContent())
                ->setName($pageView->getRelativeFilePath())
                ->setRelativeFilePath($pageView->getRelativeFilePath())
                ->buildException()
            ;

            throw $e;
        }
    }
}


Push — develop ( 38da12...667cd2 )

Compiler A

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

20 Methods

How to fix Duplicated Code

Duplicated Code

Available Fixes

Available Fixes

Available Fixes

1			<?php
2
3			/**
4			* @copyright 2018 Vladimir Jimenez
5			* @license https://github.com/stakx-io/stakx/blob/master/LICENSE.md MIT
6			*/
7
8			namespace allejo\stakx;
9
10			use allejo\stakx\Document\BasePageView;
11			use allejo\stakx\Document\CollectableItem;
12			use allejo\stakx\Document\DynamicPageView;
13			use allejo\stakx\Document\PermalinkDocument;
14			use allejo\stakx\Document\RepeaterPageView;
15			use allejo\stakx\Document\StaticPageView;
16			use allejo\stakx\Document\TemplateReadyDocument;
17			use allejo\stakx\Event\CompilerPostRenderDynamicPageView;
18			use allejo\stakx\Event\CompilerPostRenderRepeaterPageView;
19			use allejo\stakx\Event\CompilerPostRenderStaticPageView;
20			use allejo\stakx\Event\CompilerPreRenderDynamicPageView;
21			use allejo\stakx\Event\CompilerPreRenderRepeaterPageView;
22			use allejo\stakx\Event\CompilerPreRenderStaticPageView;
23			use allejo\stakx\Event\CompilerTemplateCreation;
24			use allejo\stakx\Event\RedirectPreOutput;
25			use allejo\stakx\Exception\FileAwareException;
26			use allejo\stakx\Filesystem\WritableFolder;
27			use allejo\stakx\FrontMatter\ExpandedValue;
28			use allejo\stakx\Manager\CollectionManager;
29			use allejo\stakx\Manager\DataManager;
30			use allejo\stakx\Manager\MenuManager;
31			use allejo\stakx\Manager\PageManager;
32			use allejo\stakx\Templating\TemplateBridgeInterface;
33			use allejo\stakx\Templating\TemplateErrorInterface;
34			use allejo\stakx\Templating\TemplateInterface;
35			use Psr\Log\LoggerInterface;
36			use Symfony\Component\EventDispatcher\EventDispatcherInterface;
37
38			/**
39			* This class takes care of rendering the Twig body of PageViews with the respective information and it also takes care
40			* of writing the rendered Twig to the filesystem.

stakx-io / stakx

Push — develop ( 38da12...667cd2 )

Compiler A

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

20 Methods

How to fix Duplicated Code

Duplicated Code

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like