[FEATURE] Allow defining arguments for f:render with f:argument

examples/Resources/Private/Singles/Variables.html

@@ -40,6 +40,12 @@
 	}
 }"/>
 
+<!-- Passing arguments to a sections/partials using f:render in tag content -->
+<f:render section="Tertiary">
+    <f:argument name="arg1">First argument</f:argument>
+    <f:argument name="arg2">Second argument</f:argument>
+</f:render>
+
 </f:section>
 
 <f:section name="Secondary">
@@ -49,3 +55,8 @@
 Received $array.xyz.foobar with value {array.xyz.foobar}
 Received $myVariable with value {myVariable}
 </f:section>
+
+<f:section name="Tertiary">
+Input argument "arg1" was: {arg1}
+Input argument "arg2" was: {arg2}
+</f:section>

src/Core/ViewHelper/ViewHelperVariableContainer.php

@@ -6,6 +6,7 @@
  * See LICENSE.txt that was shipped with this package.
  */
 
+use TYPO3Fluid\Fluid\Core\Variables\VariableProviderInterface;
 use TYPO3Fluid\Fluid\View\ViewInterface;
 
 /**
@@ -29,6 +30,69 @@ class ViewHelperVariableContainer
      */
     protected $view;
 
+    /**
+     * @var VariableProviderInterface[]
+     */
+    protected $delegates = [];
+
+    /**
+     * Push a new delegate variable container to a stack.
+     *
+     * If a ViewHelper requires a storage to collect variables which, for
+     * example, are filled by evaluating the child (tag content) closure,
+     * this method can be used to add a special delegate variable container
+     * stored in a stack. Once the variables you need to collect have been
+     * collected, calling `popDelegateVariableProvider` removes the delegate
+     * from the stack.
+     *
+     * The point of a stack is to avoid resetting a storage every time a
+     * ViewHelper is rendered. In the case of `f:render` it means one storage
+     * is created and filled for every one call to the ViewHelper.
+     *
+     * It is VITAL that you also "pop" any delegate you push to this stack!
+     *
+     * @param VariableProviderInterface $variableProvider
+     */
+    public function pushDelegateVariableProvider(VariableProviderInterface $variableProvider)
+    {
+        $this->delegates[] = $variableProvider;
+    }
+
+    /**
+     * Get the topmost delegate variable container that was previously pushed
+     * onto the stack by pushDelegateVariableContainer(). This method returns
+     * a reference to the storage that was last added to the stack without
+     * removing the variable provider from the stack.
+     *
+     * Is used in ViewHelpers that assign variables in variable providers in
+     * the stack - as a means to get the variable storage used by the "closest
+     * parent", e.g. when called in `f:argument` used inside `f:render`, will
+     * read the delegate variable provider inserted by that parent `f:render`.
+     *
+     * @return VariableProviderInterface|null
+     */
+    public function getTopmostDelegateVariableProvider()
+    {
+        return end($this->delegates) ?: null;
+    }
+
+    /**
+     * Return and REMOVE the topmost delegate variable provider. This method
+     * must be called after you finish sub-rendering with a delegated variable
+     * provider that was added with `pushDelegateVariableProvider`. Calling
+     * the method removes the delegate and returns the stack to the previous
+     * state it was in.
+     *
+     * To avoid removing from the stack, use `getTopmostDelegateVariableProvider`.
+     *
+     * @param string $viewHelperClassName
+     * @return VariableProviderInterface|null
+     */
+    public function popDelegateVariableProvider()
+    {
+        return array_pop($this->delegates);
+    }
+
     /**
      * Add a variable to the Variable Container. Make sure that $viewHelperName is ALWAYS set
      * to your fully qualified ViewHelper Class Name

src/ViewHelpers/ArgumentViewHelper.php

@@ -0,0 +1,68 @@
+<?php
+namespace TYPO3Fluid\Fluid\ViewHelpers;
+
+/*
+ * This file belongs to the package "TYPO3 Fluid".
+ * See LICENSE.txt that was shipped with this package.
+ */
+
+use TYPO3Fluid\Fluid\Core\Rendering\RenderingContextInterface;
+use TYPO3Fluid\Fluid\Core\ViewHelper\AbstractViewHelper;
+use TYPO3Fluid\Fluid\Core\ViewHelper\Traits\CompileWithContentArgumentAndRenderStatic;
+
+/**
+ * Argument assigning ViewHelper
+ *
+ * Assigns an argument for a parent ViewHelper call when
+ * the parent ViewHelper supports it.
+ *
+ * Alternative to declaring an array to pass as "arguments".
+ *
+ * Usages:
+ *
+ *     <f:render partial="Foo">
+ *         <f:argument name="arg1">Value1</f:argument>
+ *         <f:argument name="arg2">Value2</f:argument>
+ *     </f:render>
+ *
+ * Which is the equivalent of:
+ *
+ *     <f:render partial="Foo" arguments="{arg1: 'Value1', arg2: 'Value2'}'" />
+ *
+ * But has the benefit that writing ViewHelper expressions or
+ * other more complex syntax becomes much easier because you
+ * can use tag syntax (tag content becomes argument value).
+ *
+ * @api
+ */
+class ArgumentViewHelper extends AbstractViewHelper
+{
+    use CompileWithContentArgumentAndRenderStatic;
+
+    /**
+     * @return void
+     */
+    public function initializeArguments()
+    {
+        $this->registerArgument('value', 'mixed', 'Value to assign. If not in arguments then taken from tag content');
+        $this->registerArgument('name', 'string', 'Name of variable to create', true);
+    }
+
+    /**
+     * @param array $arguments
+     * @param \Closure $renderChildrenClosure
+     * @param RenderingContextInterface $renderingContext
+     * @return null
+     */
+    public static function renderStatic(
+        array $arguments,
+        \Closure $renderChildrenClosure,
+        RenderingContextInterface $renderingContext
+    ) {
+        $delegateVariableProvider = $renderingContext->getViewHelperVariableContainer()->getTopmostDelegateVariableProvider();
+        if ($delegateVariableProvider) {
+            $delegateVariableProvider->add($arguments['name'], $renderChildrenClosure());
+        }
+    }
+
+}

src/ViewHelpers/RenderViewHelper.php

@@ -87,7 +87,7 @@
 class RenderViewHelper extends AbstractViewHelper
 {
     use CompileWithRenderStatic;
-    
+
     /**
      * @var boolean
      */
@@ -121,7 +121,20 @@ public static function renderStatic(array $arguments, \Closure $renderChildrenCl
         $delegate = $arguments['delegate'];
         /** @var RenderableInterface $renderable */
         $renderable = $arguments['renderable'];
+
+        // Prepare a delegate variable provider that will be possible to extract after rendering the child closure.
+        // Any variable defined therein gets used as argument and overrides any argument of the same name.
+        // Note: not using late static binding here is a conscious decision: if late static binding had been used
+        // then f:variable would not be able to reference this ViewHelper class' stack variable correctly.
+        $viewHelperVariableContainer = $renderingContext->getViewHelperVariableContainer();
+        $collector = $renderingContext->getVariableProvider()->getScopeCopy($variables);
+
+        $viewHelperVariableContainer->pushDelegateVariableProvider($collector);
+
         $tagContent = $renderChildrenClosure();
+
+        $variables = $viewHelperVariableContainer->popDelegateVariableProvider()->getAll();
+
         if ($arguments['contentAs']) {
             $variables[$arguments['contentAs']] = $tagContent;
         }

tests/Functional/ExamplesTest.php

@@ -222,7 +222,9 @@ public function getExampleScriptTestValues()
                     'Received $array.printf with formatted string Formatted string, value: formatted',
                     'Received $array.baz with value 42',
                     'Received $array.xyz.foobar with value Escaped sub-string',
-                    'Received $myVariable with value Nice string'
+                    'Received $myVariable with value Nice string',
+                    'Input argument "arg1" was: First argument',
+                    'Input argument "arg2" was: Second argument',
                 ]
             ],
             'example_variableprovider.php' => [