PSFS\base\extension\AssetsTokenParser

Complexity

Total Complexity

19

Size/Duplication

Total Lines	137
Duplicated Lines	0 %

Test Coverage

Coverage

91.8%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	parse()	0	7	1
A	checkTemplateLine()	0	16	3
A	extractTemplateNodes()	0	10	2
A	getTmpAttribute()	0	11	3
A	extractTmpAttribute()	0	12	3
A	findTemplateNode()	0	11	3
A	getTag()	0	12	3

<?php

namespace PSFS\base\extension;

/**
 * Class AssetsTokenParser
 * @package PSFS\base\extension
 */
class AssetsTokenParser extends \Twig_TokenParser
{

    protected $type;
    private $values = array();
    private $end = false;

    /**
     * @param string $type
     */
    public function __construct($type = 'js')
    {
        $this->type = $type;
    }

    /**
     * @param \Twig_Token $token
     * @return AssetsNode|\Twig_Node
     * @throws \Twig_Error_Syntax
     */
    public function parse(\Twig_Token $token)
    {
        $hash = substr(md5($this->parser->getStream()->getSourceContext()->getPath()), 0, 8);
        $name = $token->getValue();
        $this->extractTemplateNodes();
        $node = $this->findTemplateNode();
        return new AssetsNode($name, array('node' => $node, 'hash' => $hash), $token->getLine(), $this->getTag(), $this->type);
    }

    /**
     * Método que devuelve el tag a buscar en la plantilla
     * @return string
     */
    public function getTag()
    {
        switch ($this->type) {
            default:
            case 'js':
                $return = 'scripts';
                break;
            case 'css':
                $return = 'styles';
                break;
        }
        return $return;
    }

    /**
     * @param \Twig_TokenStream $stream
     * @return \Twig_TokenStream
     * @throws \Twig_Error_Syntax
     */
    protected function checkTemplateLine(\Twig_TokenStream $stream)
    {
        $value = $stream->getCurrent();
        switch ($value->getType()) {
            case \Twig_Token::STRING_TYPE:
                $this->values[] = $this->parser->getExpressionParser()->parseExpression();
                break;
            case \Twig_Token::BLOCK_END_TYPE:
                $this->end = true;
                $stream->next();
                break;
            default:
                $stream->next();
                break;
        }
        return $stream;
    }

    /**
     * @throws \Twig_Error_Syntax
     */
    protected function extractTemplateNodes()
    {
        $stream = $this->parser->getStream();
        while (!$this->end) {
            $stream = $this->checkTemplateLine($stream);
        }

        $stream->expect(\Twig_Token::BLOCK_START_TYPE);
        $stream->expect(\Twig_Token::NAME_TYPE);
        $stream->expect(\Twig_Token::BLOCK_END_TYPE);
    }

    /**
     * @return mixed|null
     */
    protected function findTemplateNode()
    {
        $node = null;
        if (0 < count($this->values)) {
            /** @var \Twig_Node_Expression|\Twig_Node_Expression_Conditional $value */
            foreach ($this->values as $value) {
                list($tmp, $node) = $this->extractTmpAttribute($node, $value);
                $node->setAttribute('value', $tmp);
            }
        }
        return $node;
    }

    /**
     * @param null $node

Are you sure the doc-type for parameter $node is correct as it would always require null to be passed?

     * @return array
     */
    protected function getTmpAttribute($node = null)
    {
        $tmp = [];
        if(null !== $node) {

The condition null !== $node is always false.

            $tmp = $node->getAttribute('value');
            if (!is_array($tmp)) {
                $tmp = [$tmp];
            }
        }

        return $tmp;
    }

    /**
     * Método
     * @param \Twig_Node_Expression|\Twig_Node_Expression_Conditional|null $node
     * @param \Twig_Node_Expression|\Twig_Node_Expression_Conditional|null $value
     *
     * @return array
     */
    protected function extractTmpAttribute($node = null, $value = null)
    {
        $tmp = [];
        if (null === $node) {
            $node = $value;
        } else {
            $tmp = $this->getTmpAttribute($node);
        }
        if(null !== $node) {
            $tmp[] = $value->getAttribute('value');

The method getAttribute() does not exist on null.

        }
        return [$tmp, $node];
    }
}