allejo\stakx\Templating\Twig\TwigExtension

Complexity

Total Complexity

18

Size/Duplication

Total Lines	96
Duplicated Lines	27.08 %

Coupling/Cohesion

Components	2
Dependencies	5

Test Coverage

Coverage

25.64%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	__call()	0	11	2
A	parseMarkup()	0	4	1
A	addFilters()	13	13	4
A	addFunctions()	13	13	4
A	getName()	0	4	1
A	getFilters()	0	17	2
A	getFunctions()	0	4	1
A	getTokenParsers()	0	11	2

<?php

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

namespace allejo\stakx\Templating\Twig;

use allejo\stakx\MarkupEngine\MarkupEngineManager;
use allejo\stakx\RuntimeStatus;
use allejo\stakx\Service;
use allejo\stakx\Templating\Twig\Extension\AbstractTwigExtension;
use allejo\stakx\Templating\Twig\Extension\TwigFilterInterface;
use allejo\stakx\Templating\Twig\Extension\TwigFunctionInterface;
use allejo\stakx\Templating\Twig\MarkupBlock\TokenParser;
use Twig\Extension\AbstractExtension;
use Twig\TwigFilter;

class TwigExtension extends AbstractExtension
{
    private $filters = [];
    private $functions = [];
    private $markupManager;

    public function __construct(MarkupEngineManager $manager)
    {
        $this->markupManager = $manager;
    }

    public function __call($name, $arguments)

The return type could not be reliably inferred; please add a @return annotation.

    {
        $tag = lcfirst(str_replace('parseMarkup', '', $name));

        if (!$tag)
        {
            throw new \BadMethodCallException("No method $name found in this class.");
        }

        return $this->parseMarkup($arguments[0], $tag);
    }

    public function parseMarkup($content, $tag)

The return type could not be reliably inferred; please add a @return annotation.

    {
        return $this->markupManager->getEngineByTag($tag)->parse($content);
    }

    public function addFilters(/*iterable*/ $filters)

This method seems to be duplicated in your project.

    {
        /** @var AbstractTwigExtension|TwigFilterInterface $filter */
        foreach ($filters as $filter)
        {
            if (Service::hasRunTimeFlag(RuntimeStatus::IN_SAFE_MODE) && $filter::disableInSafeMode())
            {
                continue;
            }

            $this->filters[] = $filter::get();
        }
    }

    public function addFunctions(/*iterable*/ $functions)

This method seems to be duplicated in your project.

    {
        /** @var AbstractTwigExtension|TwigFunctionInterface $fxn */
        foreach ($functions as $fxn)
        {
            if (Service::hasRunTimeFlag(RuntimeStatus::IN_SAFE_MODE) && $fxn::disableInSafeMode())
            {
                continue;
            }

            $this->functions[] = $fxn::get();
        }
    }

    public function getFilters()
    {
        $filters = $this->filters;

        foreach ($this->markupManager->getTemplateTags() as $tag)
        {
            // Since we can't pass what tag/markup language we're using to the callable, let's make the callable to a
            // non-existent method that will be handled by __call()
            $filters[] = new TwigFilter(
                $tag,
                [$this, 'parseMarkup' . ucfirst($tag)],
                ['is_safe' => ['html']]
            );
        }

        return $filters;
    }

    public function getFunctions()
    {
        return $this->functions;
    }

    public function getTokenParsers()
    {
        $tokenParsers = [];

        foreach ($this->markupManager->getTemplateTags() as $tag)
        {
            $tokenParsers[] = new TokenParser($tag);
        }

        return $tokenParsers;
    }

    public function getName()
    {
        return 'stakx_twig_base_extension';
    }
}