如何在 twig 2 中获取 _self 的对象 - 使用字符串，属性（_self，函数）在更新后总是失败

Question

I will update our twig to 2.11. We use folowing code currently:

{% set neededFunction = 'someting_dynamic' %}
{% import _self as functions %}
{% if attribute(functions, neededFunction ) is defined %}
    {# do something #}
{% else %}
    {# do something else #}
{% endif %}

but after update "attribute(functions, neededFunction )" fails always. I think its because _self is no object now. But what can i do now to check if a dynamic named function exist?

update:

I tried the following:

{% set neededFunction = 'someting_dynamic' %}
{% import 'myTemplate' as functions %} 

{% if attribute(functions, neededFunction ) is defined %} 
    {# do something #}
{% endif %} 

{% if functions.neededFunction is defined %}
    {# do something #}
{% endif %}

{% if functions.someting_dynamic is defined %}
    {# do something #}
{% endif %} 

only the last one works. But this is not dynamic

update: Try to solve the Problem with the approach of DarkBee.

Now there is one last Problem:

Before I compile a Macro, I want to check, if the Macro exist. If not, I want to call a default macro. But I have the problem, that the $function is not compiled. Can i get the Value of the compiled content from parser?

My TokenParser:

class DynamicMacro extends \Twig\TokenParser\AbstractTokenParser
{
    const MAX_MACROS = 2;

    /**
     * @var Node
     */
    private $firstAvailableNode;

    /**
     * {@inheritDoc}
     */
    public function getTag()
    {
        return 'dynamic_macro';
    }

    /**
     * {@inheritDoc}
     */
    public function parse(Token $token)
    {
        $stream = $this->parser->getStream();

        $name = $stream->expect(Token::NAME_TYPE)->getValue();

        for ($i = 1; $i <= self::MAX_MACROS; $i++) {
            if (!$stream->test(Token::BLOCK_END_TYPE)) {
                $this->checkMacro( $token, $name );
            }
        }

        $this->parser->getStream()->expect(Token::BLOCK_END_TYPE);

        return $this->getFirstAvailableNode();
    }

    private function checkMacro( Token $token, string $name )
    {
        $stream = $this->parser->getStream();

        $stream->expect(\Twig_Token::PUNCTUATION_TYPE);
        $function = $stream->expect(\Twig_Token::NAME_TYPE)->getValue();

        $arguments = $this->parser->getExpressionParser()->parseArguments(true);

        /** @todo: $function -> 'fx' has to be compiled  */
        if (is_null($this->firstAvailableNode) && $this->parser->hasMacro($function)){
            $node = new DynamicMacroNode($name, $function, $arguments, $token->getLine(), $this->getTag());
            $this->setFirstAvailableNode($node);
        }
    }

    /**
     * @return Node
     */
    public function getFirstAvailableNode(): Node
    {
        if(is_null($this->firstAvailableNode))
            return new EmptyNode();

        return $this->firstAvailableNode;
    }

    /**
     * @param Node $node
     */
    public function setFirstAvailableNode(Node $node)
    {
        if (is_null($this->firstAvailableNode))
            $this->firstAvailableNode = $node;
    }


}

Twig Snipped:

{% import _self as foo_macro %}
{% set fx = 'foo_function' %}
{% set fxdef = 'foo_function_default' %}

{% dynamic_macro foo_macro.fx('bar', 'foo', 42, fx).fxdef('bar', 'foo', 42, fx) %}

{% macro foo_function_default(bar, foo, int, function) %}
   Bar: {{ bar }}<br />
   Foo: {{ foo }}<br />
   Int: {{ int }}<br />
   Fx: {{ function }}<br />
{% endmacro %}

Answer 1

You could create your own tag in twig which solves this isue

Register custom TokenParser inside your extension:

class MyTwigExtension implements \Twig\Extension\ExtensionInterface {
    public function getTokenParsers() {
        return [
            new DynamicMacro(),
        ];
    }
}

Create the TokenParser

class DynamicMacro extends \Twig\TokenParser\AbstractTokenParser {
    /**
     * {@inheritDoc}
     */
    public function getTag()
    {
        return 'dynamic_macro';
    }
    /**
     * {@inheritDoc}
     */
    public function parse(\Twig\Token $token)
    {
        $parser = $this->parser;
        $stream = $parser->getStream();

        $name = $stream->expect(\Twig_Token::NAME_TYPE)->getValue();
        $stream->expect(\Twig_Token::PUNCTUATION_TYPE);
        $function = $stream->expect(\Twig_Token::NAME_TYPE)->getValue();

        $arguments = $this->parser->getExpressionParser()->parseArguments(true);
        $stream->expect(\Twig_Token::BLOCK_END_TYPE);

        return new DynamicMacroNode($name, $function, $arguments, $token->getLine(), $this->getTag());
    }
}

Create the Node

    class DynamicMacroNode extends \Twig\Node\Node {
        public function __construct($name, $function, $arguments, $lineno, $tag = null) {
            $attributes = [
                'name'      => $name,
                'function'  => $function,
                'lineno'    => $lineno,
            ];
            parent::__construct([ 'arguments' => $arguments, ], $attributes, $lineno, $tag);
        }

        public function compile(\Twig_Compiler $compiler) {
            $compiler->write('$_dynamicMacro_parms = [];')
                     ->raw("\n");
            foreach($this->getNode('arguments') as $argument) {
                $compiler->write('$_dynamicMacro_parms[] = ')
                         ->subcompile($argument)
                         ->raw(";\n");
            }
            $compiler->write('echo twig_call_macro($macros[\''.$this->getAttribute('name').'\'], \'macro_\'.$context[\''.$this->getAttribute('function').'\'] ?? null, $_dynamicMacro_parms,'.$this->getAttribute('lineno').', $context, $this->getSourceContext());');
        }
    }

Now you can use the tag dynamic_macro inside twig

        {% import _self as foo_macro %}
        {% set fx = 'foo_function' %}

        {% dynamic_macro foo_macro.fx('bar', 'foo', 42, fx) %}

        {% macro foo_function(bar, foo, int, function) %}
            Bar: {{ bar }}<br />
            Foo: {{ foo }}<br />
            Int: {{ int }}<br />
            Fx: {{ function }}<br />
        {% endmacro %}

---

please not this only a rough version on how you can solve this issue and should be further expanded with validating the data and such