12237686280

Committed 09 Dec 2024 02:27PM UTC coverage: 92.9% (-0.5%) from 93.421%

Build # 12237686280

Build Type

push

github

Committed by

NamelessCoder

Commit Message

[TER] 10.1.0

Run Details

7013 of 7549 relevant lines covered (92.9%)

56.22 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.94

/Classes/ViewHelpers/AbstractFormViewHelper.php

<?php
declare(strict_types=1);
namespace FluidTYPO3\Flux\ViewHelpers;

/*
 * This file is part of the FluidTYPO3/Flux project under GPLv2 or later.
 *
 * For the full copyright and license information, please read the
 * LICENSE.md file that was distributed with this source code.
 */

use FluidTYPO3\Flux\Form;
use FluidTYPO3\Flux\Form\Container\Grid;
use FluidTYPO3\Flux\Form\FormInterface;
use TYPO3Fluid\Fluid\Component\Argument\ArgumentCollection;
use TYPO3Fluid\Fluid\Core\Rendering\RenderingContextInterface;
use TYPO3Fluid\Fluid\Core\ViewHelper\AbstractViewHelper;

/**
 * Base class for all FlexForm related ViewHelpers
 */
abstract class AbstractFormViewHelper extends AbstractViewHelper
{
    const SCOPE = FormViewHelper::class;
    const SCOPE_VARIABLE_EXTENSIONNAME = 'extensionName';
    const SCOPE_VARIABLE_FORM = 'form';
    const SCOPE_VARIABLE_CONTAINER = 'container';
    const SCOPE_VARIABLE_GRIDS = 'grids';

    /**
     * @return string
     */
    public function render()
    {
        return static::renderStatic($this->arguments, $this->buildRenderChildrenClosure(), $this->renderingContext);
    }

    protected function callRenderMethod(): string
    {
        return static::renderStatic(
            $this->arguments instanceof ArgumentCollection ? $this->arguments->getArrayCopy() : $this->arguments,
            $this->buildRenderChildrenClosure(),
            $this->renderingContext
        );
    }

    public static function renderStatic(
        array $arguments,
        \Closure $renderChildrenClosure,
        RenderingContextInterface $renderingContext
    ): string {
        $container = static::getContainerFromRenderingContext($renderingContext);
        if (method_exists(static::class, 'getComponent')) {
            $component = static::getComponent($renderingContext, $arguments, $renderChildrenClosure);
            // rendering child nodes with Form's last sheet as active container
            static::setContainerInRenderingContext($renderingContext, $component);
        }
        $renderChildrenClosure();
        static::setContainerInRenderingContext($renderingContext, $container);

        return '';
    }

    public static function getComponent(
        RenderingContextInterface $renderingContext,
        iterable $arguments
    ): FormInterface {
        return Form::create();
    }

    /**
     * @return mixed
     */
    public function renderChildren()
    {
        // Make sure the current extension name always propagates to child nodes
        static::setExtensionNameInRenderingContext(
            $this->renderingContext,
            static::getExtensionNameFromRenderingContextOrArguments($this->renderingContext, $this->arguments)
        );

        return parent::renderChildren();
    }

    protected static function setExtensionNameInRenderingContext(
        RenderingContextInterface $renderingContext,
        string $name
    ): void {
        $renderingContext->getViewHelperVariableContainer()
            ->addOrUpdate(static::SCOPE, static::SCOPE_VARIABLE_EXTENSIONNAME, $name);
    }

    protected static function getExtensionNameFromRenderingContextOrArguments(
        RenderingContextInterface $renderingContext,
        array $arguments
    ): string {
        if ($extensionName = $arguments[static::SCOPE_VARIABLE_EXTENSIONNAME] ?? false) {
            return (string) $extensionName;
        }
        $viewHelperVariableContainer = $renderingContext->getViewHelperVariableContainer();
        if ($extensionName = $viewHelperVariableContainer->get(static::SCOPE, static::SCOPE_VARIABLE_EXTENSIONNAME)) {
            return is_scalar($extensionName) ? (string) $extensionName : 'FluidTYPO3.Flux';
        }
        $request = null;
        $controllerContext = null;
        if (method_exists($renderingContext, 'getControllerContext')) {
            $controllerContext = $renderingContext->getControllerContext();
            if ($controllerContext && $controllerContext->getRequest()) {
                $request = $controllerContext->getRequest();
            }
        } elseif (method_exists($renderingContext, 'getRequest')) {
            $request = $renderingContext->getRequest();
        }
        if (!$request && $controllerContext) {
            $request = $controllerContext->getRequest();
            /** @var string|null $controllerExtensionName */
            $controllerExtensionName = $request->getControllerExtensionName();
            return $controllerExtensionName ?? 'FluidTYPO3.Flux';
        }
        return 'FluidTYPO3.Flux';
    }

    public static function getFormFromRenderingContext(RenderingContextInterface $renderingContext): Form
    {
        /** @var Form|null $form */
        $form = $renderingContext->getViewHelperVariableContainer()->get(static::SCOPE, static::SCOPE_VARIABLE_FORM);
        if (!$form) {
            $form = Form::create([
                'extensionName' => $renderingContext->getViewHelperVariableContainer()->get(
                    FormViewHelper::SCOPE,
                    FormViewHelper::SCOPE_VARIABLE_EXTENSIONNAME
                )
            ]);
            $renderingContext->getViewHelperVariableContainer()->add(static::SCOPE, static::SCOPE_VARIABLE_FORM, $form);
        }
        return $form;
    }

    protected static function getGridFromRenderingContext(
        RenderingContextInterface $renderingContext,
        string $gridName = 'grid'
    ): Grid {
        $viewHelperVariableContainer = $renderingContext->getViewHelperVariableContainer();
        /** @var Grid[] $grids */
        $grids = (array) $viewHelperVariableContainer->get(static::SCOPE, static::SCOPE_VARIABLE_GRIDS);

        if (!isset($grids[$gridName])) {
            $grids[$gridName] = Grid::create(['name' => $gridName]);
            $viewHelperVariableContainer->addOrUpdate(static::SCOPE, static::SCOPE_VARIABLE_GRIDS, $grids);
        }
        /** @var Grid $grid */
        $grid = $grids[$gridName];
        return $grid;
    }

    protected static function getContainerFromRenderingContext(
        RenderingContextInterface $renderingContext
    ): FormInterface {
        /** @var Form\FormInterface|null $container */
        $container = $renderingContext->getViewHelperVariableContainer()->get(
            static::SCOPE,
            static::SCOPE_VARIABLE_CONTAINER
        );
        return $container ?? static::getFormFromRenderingContext($renderingContext);
    }

    protected static function setContainerInRenderingContext(
        RenderingContextInterface $renderingContext,
        FormInterface $container
    ): void {
        $renderingContext->getViewHelperVariableContainer()->addOrUpdate(
            static::SCOPE,
            static::SCOPE_VARIABLE_CONTAINER,
            $container
        );
    }
}

1	<?php
2	declare(strict_types=1);
3	namespace FluidTYPO3\Flux\ViewHelpers;
4
5	/*
6	* This file is part of the FluidTYPO3/Flux project under GPLv2 or later.
7	*
8	* For the full copyright and license information, please read the
9	* LICENSE.md file that was distributed with this source code.
10	*/
11
12	use FluidTYPO3\Flux\Form;
13	use FluidTYPO3\Flux\Form\Container\Grid;
14	use FluidTYPO3\Flux\Form\FormInterface;
15	use TYPO3Fluid\Fluid\Component\Argument\ArgumentCollection;
16	use TYPO3Fluid\Fluid\Core\Rendering\RenderingContextInterface;
17	use TYPO3Fluid\Fluid\Core\ViewHelper\AbstractViewHelper;
18
19	/**
20	* Base class for all FlexForm related ViewHelpers
21	*/
22	abstract class AbstractFormViewHelper extends AbstractViewHelper
23	{
24	const SCOPE = FormViewHelper::class;
25	const SCOPE_VARIABLE_EXTENSIONNAME = 'extensionName';
26	const SCOPE_VARIABLE_FORM = 'form';
27	const SCOPE_VARIABLE_CONTAINER = 'container';
28	const SCOPE_VARIABLE_GRIDS = 'grids';
29
30	/**
31	* @return string
32	*/
33	public function render()
34	{
35	return static::renderStatic($this->arguments, $this->buildRenderChildrenClosure(), $this->renderingContext);	×
36	}
37
38	protected function callRenderMethod(): string
39	{
40	return static::renderStatic(	276✔
41	$this->arguments instanceof ArgumentCollection ? $this->arguments->getArrayCopy() : $this->arguments,	276✔
42	$this->buildRenderChildrenClosure(),	276✔
43	$this->renderingContext	276✔
44	);	276✔
45	}
46
47	public static function renderStatic(
48	array $arguments,
49	\Closure $renderChildrenClosure,
50	RenderingContextInterface $renderingContext
51	): string {
52	$container = static::getContainerFromRenderingContext($renderingContext);	228✔
53	if (method_exists(static::class, 'getComponent')) {	228✔
54	$component = static::getComponent($renderingContext, $arguments, $renderChildrenClosure);	228✔
55	// rendering child nodes with Form's last sheet as active container
56	static::setContainerInRenderingContext($renderingContext, $component);	222✔
57	}
58	$renderChildrenClosure();	222✔
59	static::setContainerInRenderingContext($renderingContext, $container);	222✔
60
61	return '';	222✔
62	}
63
64	public static function getComponent(
65	RenderingContextInterface $renderingContext,
66	iterable $arguments
67	): FormInterface {
68	return Form::create();	6✔
69	}
70
71	/**
72	* @return mixed
73	*/
74	public function renderChildren()
75	{
76	// Make sure the current extension name always propagates to child nodes
77	static::setExtensionNameInRenderingContext(	138✔
78	$this->renderingContext,	138✔
79	static::getExtensionNameFromRenderingContextOrArguments($this->renderingContext, $this->arguments)	138✔
80	);	138✔
81
82	return parent::renderChildren();	138✔
83	}
84
85	protected static function setExtensionNameInRenderingContext(
86	RenderingContextInterface $renderingContext,
87	string $name
88	): void {
89	$renderingContext->getViewHelperVariableContainer()	138✔
90	->addOrUpdate(static::SCOPE, static::SCOPE_VARIABLE_EXTENSIONNAME, $name);	138✔
91	}
92
93	protected static function getExtensionNameFromRenderingContextOrArguments(
94	RenderingContextInterface $renderingContext,
95	array $arguments
96	): string {
97	if ($extensionName = $arguments[static::SCOPE_VARIABLE_EXTENSIONNAME] ?? false) {	382✔
98	return (string) $extensionName;	6✔
99	}
100	$viewHelperVariableContainer = $renderingContext->getViewHelperVariableContainer();	376✔
101	if ($extensionName = $viewHelperVariableContainer->get(static::SCOPE, static::SCOPE_VARIABLE_EXTENSIONNAME)) {	376✔
102	return is_scalar($extensionName) ? (string) $extensionName : 'FluidTYPO3.Flux';	76✔
103	}
104	$request = null;	376✔
105	$controllerContext = null;	376✔
106	if (method_exists($renderingContext, 'getControllerContext')) {	376✔
107	$controllerContext = $renderingContext->getControllerContext();	284✔
108	if ($controllerContext && $controllerContext->getRequest()) {	284✔
109	$request = $controllerContext->getRequest();	256✔
110	}
111	} elseif (method_exists($renderingContext, 'getRequest')) {	92✔
112	$request = $renderingContext->getRequest();	92✔
113	}
114	if (!$request && $controllerContext) {	376✔
115	$request = $controllerContext->getRequest();	×
116	/** @var string\|null $controllerExtensionName */
117	$controllerExtensionName = $request->getControllerExtensionName();	×
118	return $controllerExtensionName ?? 'FluidTYPO3.Flux';	×
119	}
120	return 'FluidTYPO3.Flux';	376✔
121	}
122
123	public static function getFormFromRenderingContext(RenderingContextInterface $renderingContext): Form
124	{
125	/** @var Form\|null $form */
126	$form = $renderingContext->getViewHelperVariableContainer()->get(static::SCOPE, static::SCOPE_VARIABLE_FORM);	396✔
127	if (!$form) {	396✔
128	$form = Form::create([	342✔
129	'extensionName' => $renderingContext->getViewHelperVariableContainer()->get(	342✔
130	FormViewHelper::SCOPE,	342✔
131	FormViewHelper::SCOPE_VARIABLE_EXTENSIONNAME	342✔
132	)	342✔
133	]);	342✔
134	$renderingContext->getViewHelperVariableContainer()->add(static::SCOPE, static::SCOPE_VARIABLE_FORM, $form);	342✔
135	}
136	return $form;	396✔
137	}
138
139	protected static function getGridFromRenderingContext(
140	RenderingContextInterface $renderingContext,
141	string $gridName = 'grid'
142	): Grid {
143	$viewHelperVariableContainer = $renderingContext->getViewHelperVariableContainer();	78✔
144	/** @var Grid[] $grids */
145	$grids = (array) $viewHelperVariableContainer->get(static::SCOPE, static::SCOPE_VARIABLE_GRIDS);	78✔
146
147	if (!isset($grids[$gridName])) {	78✔
148	$grids[$gridName] = Grid::create(['name' => $gridName]);	72✔
149	$viewHelperVariableContainer->addOrUpdate(static::SCOPE, static::SCOPE_VARIABLE_GRIDS, $grids);	72✔
150	}
151	/** @var Grid $grid */
152	$grid = $grids[$gridName];	78✔
153	return $grid;	78✔
154	}
155
156	protected static function getContainerFromRenderingContext(
157	RenderingContextInterface $renderingContext
158	): FormInterface {
159	/** @var Form\FormInterface\|null $container */
160	$container = $renderingContext->getViewHelperVariableContainer()->get(	432✔
161	static::SCOPE,	432✔
162	static::SCOPE_VARIABLE_CONTAINER	432✔
163	);	432✔
164	return $container ?? static::getFormFromRenderingContext($renderingContext);	432✔
165	}
166
167	protected static function setContainerInRenderingContext(
168	RenderingContextInterface $renderingContext,
169	FormInterface $container
170	): void {
171	$renderingContext->getViewHelperVariableContainer()->addOrUpdate(	240✔
172	static::SCOPE,	240✔
173	static::SCOPE_VARIABLE_CONTAINER,	240✔
174	$container	240✔
175	);	240✔
176	}
177	}

FluidTYPO3 / flux / 12237686280

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous