DiscoverRoutingFunctionNodeVisitor::isDiscoveredNode() - Code Metrics - yarhon/RouteGuardBundle - Measure and Improve Code Quality continuously with Scrutinizer

isDiscoveredNode() A
last analyzed 2018-12-01 21:53 UTC

↳ Parent: DiscoverRoutingFunctionNodeVisitor

Complexity

Conditions	2
Paths	2

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	2

Importance

Changes

Metric	Value
eloc	1
dl	0
loc	3
rs	10
c	0
b	0
f	0
ccs	2
cts	2
cp	1
cc	2
nc	2
nop	1
crap	2

<?php

/*
 *
 * (c) Yaroslav Honcharuk <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Yarhon\RouteGuardBundle\Twig\NodeVisitor;

use Twig\Node\Node;
use Twig\Environment;
use Twig\NodeVisitor\AbstractNodeVisitor;
use Twig\NodeVisitor\NodeVisitorInterface;
use Twig\Node\Expression\FunctionExpression;
use Twig\Node\Expression\NameExpression;
use Twig\Error\SyntaxError;
use Yarhon\RouteGuardBundle\Twig\Node\RouteNode;
use Yarhon\RouteGuardBundle\Twig\Node\RouteExpression;

/**
 * Note: we extend from AbstractNodeVisitor just for compatibility with Twig 1.x NodeVisitorInterface.
 * When this compatibility would no longer be needed, we could drop usage of AbstractNodeVisitor
 * and implement NodeVisitorInterface directly.
 *
 * @author Yaroslav Honcharuk <[email protected]>
 */
class DiscoverRoutingFunctionNodeVisitor extends AbstractNodeVisitor
{
    /**
     * @var DiscoveredFunctions
     */
    private $discoveredFunctions;

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

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

    /**
     * @var Scope
     */
    private $scope;

    /**
     * @param string $tagName
     * @param string $tagVariableName
     */
    public function __construct($tagName, $tagVariableName)
    {
        $this->tagName = $tagName;
        $this->tagVariableName = $tagVariableName;
        $this->discoveredFunctions = new DiscoveredFunctions();
        $this->scope = new Scope();
    }

    /**
     * {@inheritdoc}
     */
    protected function doEnterNode(Node $node, Environment $env)
    {
        if ($this->isTargetNode($node)) {
            $this->scope = $this->scope->enter();
            $this->scope->set('insideTargetNode', true);
        }

        return $node;
    }

    /**
     * {@inheritdoc}
     *
     * @throws SyntaxError If zero / more than one routing function calls was found inside node
     */
    protected function doLeaveNode(Node $node, Environment $env)
    {
        if ($this->isTargetNode($node)) {
            /* @var RouteNode $node */

            if (!$this->scope->has('routingFunction')) {
                throw new SyntaxError(
                    sprintf('"%s" tag with discover option must contain one %s call.', $this->tagName, $this->createDiscoveredFunctionsString()),
                    $node->getTemplateLine()
                );
            }

            $condition = $this->createRouteExpression($this->scope->get('routingFunction'), $node->getTemplateLine());
            $condition = $this->createRouteExpression(/** @scrutinizer ignore-type */ $this->scope->get('routingFunction'), $node->getTemplateLine());
            $node->setNode('condition', $condition);

            $this->scope->set('insideTargetNode', false);
            $this->scope = $this->scope->leave();

            return $node;
        }

        if ($this->scope->get('insideTargetNode') && $this->isDiscoveredNode($node)) {
            if ($this->scope->has('routingFunction')) {
                throw new SyntaxError(
                    sprintf('"%s" tag with discover option must contain only one %s call.', $this->tagName, $this->createDiscoveredFunctionsString()),
                    $node->getTemplateLine()
                );
            }

            $this->scope->set('routingFunction', $node);

            $newNode = new NameExpression($this->tagVariableName, $node->getTemplateLine());
            $newNode->setAttribute('always_defined', true);

            return $newNode;
        }

        return $node;
    }

    /**
     * {@inheritdoc}
     */
    public function getPriority()
    {
        return 0;
    }

    /**
     * @param Node $node
     *
     * @return bool
     */
    private function isTargetNode(Node $node)
    {
        return $node instanceof RouteNode && !$node->hasNode('condition');
    }

    /**
     * @param Node $node
     *
     * @return bool
     */
    private function isDiscoveredNode(Node $node)
    {
        return $node instanceof FunctionExpression && $this->discoveredFunctions->has($node->getAttribute('name'));
    }

    /**
     * @param FunctionExpression $function
     * @param int                $line
     *
     * @return RouteExpression
     *
     * @throws SyntaxError
     */
    private function createRouteExpression(FunctionExpression $function, $line)
    {
        $functionName = $function->getAttribute('name');
        $functionArguments = [];
        foreach ($function->getNode('arguments') as $argument) {
            $functionArguments[] = $argument;
        }

        list($arguments, $generateAs) = $this->discoveredFunctions->resolveArguments($functionName, $functionArguments);

        $expression = new RouteExpression(new Node($arguments), $line);
        $expression->setGenerateAs(...$generateAs);
        $expression->setGenerateAs(/** @scrutinizer ignore-type */ ...$generateAs);

        return $expression;
    }

    /**
     * @return string
     */
    private function createDiscoveredFunctionsString()
    {
        $functions = $this->discoveredFunctions->getFunctions();
        $functions = array_map(function ($name) {
            return '"'.$name.'()"';
        }, $functions);

        return implode(' / ', $functions);
    }
}


yarhon / RouteGuardBundle

isDiscoveredNode() A last analyzed 2018-12-01 21:53 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

isDiscoveredNode() A
last analyzed 2018-12-01 21:53 UTC