RootForm::view() - Code Metrics - Inspection of "PHP 8.1 compatibility" - b2pweb/bdf-form - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#3)

by Vincent

created 2022-02-01 14:40 UTC

RootForm::view() A

↳ Parent: RootForm

Complexity

Conditions	2
Paths	2

Size

Total Lines	13
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

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

<?php

namespace Bdf\Form\Aggregate;

use BadMethodCallException;
use Bdf\Form\Button\ButtonInterface;
use Bdf\Form\Child\ChildInterface;
use Bdf\Form\Child\Http\HttpFieldPath;
use Bdf\Form\ElementInterface;
use Bdf\Form\Error\FormError;
use Bdf\Form\RootElementInterface;
use Bdf\Form\View\ElementViewInterface;
use Iterator;
use OutOfBoundsException;
use Symfony\Component\PropertyAccess\PropertyAccess;
use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
use Symfony\Component\Validator\Constraint;
use Symfony\Component\Validator\Validator\ValidatorInterface;
use Symfony\Component\Validator\ValidatorBuilder;
use WeakReference;

/**
 * Adapt a form element as root element
 * The root form handle constraint group, validator and property accessor instances, and submit button
 *
 * The root form should be used instead of the form element for `submit()`
 *
 * <code>
 * $form = new MyForm();
 *
 * $root = $form->root();
 * if (!$root->submit($request->post())->valid()) {
 *     throw new MyError();
 * }
 *
 * $entity = $root->value();
 *
 * switch ($btn = $root->submitButton() ? $btn->name() : null) {
 *     case 'save':
 *         return $this->save($entity);
 *
 *     case 'delete':
 *         return $this->delete($entity);
 *
 *     default:
 *         throw new InvalidAction();
 * }
 * </code>
 *
 * @todo delegation trait
 */
final class RootForm implements RootElementInterface, ChildAggregateInterface
{
    /**
     * @var WeakReference<Form>
     */
    private $form;

    /**
     * @var array<non-empty-string, ButtonInterface>

     */
    private $buttons;

    /**
     * @var ButtonInterface|null
     */
    private $submitButton;

    /**
     * @var PropertyAccessorInterface|null
     */
    private $propertyAccessor;

    /**
     * @var ValidatorInterface|null
     */
    private $validator;


    /**
     * RootForm constructor.
     *
     * @param Form $form
     * @param array<non-empty-string, ButtonInterface> $buttons Buttons, indexed by there name

     * @param PropertyAccessorInterface|null $propertyAccessor
     * @param ValidatorInterface|null $validator
     */
    public function __construct(Form $form, array $buttons = [], ?PropertyAccessorInterface $propertyAccessor = null, ?ValidatorInterface $validator = null)
    {
        $this->form = WeakReference::create($form);
        $this->buttons = $buttons;
        $this->propertyAccessor = $propertyAccessor;
        $this->validator = $validator;
    }

    /**
     * {@inheritdoc}
     */
    public function submit($data): ElementInterface
    {
        $this->submitToButtons($data);
        /** @psalm-suppress PossiblyNullReference */
        $this->form->get()->submit($data);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function patch($data): ElementInterface
    {
        $this->submitToButtons($data);
        /** @psalm-suppress PossiblyNullReference */
        $this->form->get()->patch($data);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function import($entity): ElementInterface
    {
        /** @psalm-suppress PossiblyNullReference */
        $this->form->get()->import($entity);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function value()
    {
        /** @psalm-suppress PossiblyNullReference */
        return $this->form->get()->value();
    }

    /**
     * {@inheritdoc}
     */
    public function httpValue()
    {
        /** @psalm-suppress PossiblyNullReference */
        $httpValue = $this->form->get()->httpValue();

        if (empty($this->buttons)) {
            return $httpValue;
        }

        $httpValue = (array) $httpValue;

        foreach ($this->buttons as $btn) {
            $httpValue += $btn->toHttp();
        }

        return $httpValue;
    }

    /**
     * {@inheritdoc}
     */
    public function valid(): bool
    {
        /** @psalm-suppress PossiblyNullReference */
        return $this->form->get()->valid();
    }

    /**
     * {@inheritdoc}
     */
    public function error(?HttpFieldPath $field = null): FormError
    {
        /** @psalm-suppress PossiblyNullReference */
        return $this->form->get()->error($field);
    }

    /**
     * {@inheritdoc}
     */
    public function container(): ?ChildInterface
    {
        return null; // root cannot have a container
    }

    /**
     * {@inheritdoc}
     */
    public function setContainer(ChildInterface $container): ElementInterface
    {
        throw new BadMethodCallException('Cannot wrap a root element into a container');
    }

    /**
     * {@inheritdoc}
     */
    public function root(): RootElementInterface
    {
        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function view(?HttpFieldPath $field = null): ElementViewInterface
    {
        $buttons = [];

        foreach ($this->buttons as $button) {
            $buttons[$button->name()] = $button->view($field);
        }

        /** @psalm-suppress PossiblyNullReference */
        $view = $this->form->get()->view($field);
        $view->setButtons($buttons);

        return $view;
    }

    /**
     * {@inheritdoc}
     */
    public function submitButton(): ?ButtonInterface
    {
        return $this->submitButton;
    }

    /**
     * {@inheritdoc}
     */
    public function button(string $name): ButtonInterface
    {
        if ($btn = $this->buttons[$name] ?? null) {
            return $btn;
        }

        throw new OutOfBoundsException("The button '{$name}' is not found");
    }

    /**
     * {@inheritdoc}
     */
    public function getValidator(): ValidatorInterface
    {
        if ($this->validator === null) {
            $this->validator = (new ValidatorBuilder())->getValidator();
        }

        return $this->validator;
    }

    /**
     * {@inheritdoc}
     */
    public function getPropertyAccessor(): PropertyAccessorInterface
    {
        if ($this->propertyAccessor === null) {
            $this->propertyAccessor = PropertyAccess::createPropertyAccessor();
        }

        return $this->propertyAccessor;
    }

    /**
     * {@inheritdoc}
     */
    public function constraintGroups(): array
    {
        if (!$button = $this->submitButton) {
            return [Constraint::DEFAULT_GROUP];
        }

        return $button->constraintGroups() ?: [Constraint::DEFAULT_GROUP];
    }

    /**
     * {@inheritdoc}
     *
     * @psalm-suppress InvalidNullableReturnType
     * @psalm-suppress PossiblyNullReference
     * @psalm-suppress PossiblyNullArrayAccess
     * @psalm-suppress NullableReturnStatement
     */
    public function offsetGet($offset): ChildInterface
    {
        return $this->form->get()[$offset];
    }

    /**
     * {@inheritdoc}
     */
    public function offsetExists($offset): bool
    {
        /** @psalm-suppress PossiblyNullReference */
        return isset($this->form->get()[$offset]);
    }

    /**
     * {@inheritdoc}
     */
    public function offsetSet($offset, $value): void
    {
        /** @psalm-suppress PossiblyNullReference */
        $this->form->get()[$offset] = $value;
    }

    /**
     * {@inheritdoc}
     *
     * @psalm-suppress PossiblyNullReference
     * @psalm-suppress PossiblyNullArrayAccess
     */
    public function offsetUnset($offset): void
    {
        unset($this->form->get()[$offset]);
    }

    /**
     * {@inheritdoc}
     */
    public function getIterator(): Iterator
    {
        /** @psalm-suppress PossiblyNullReference */
        return $this->form->get()->getIterator();
    }

    /**
     * Submit HTTP fields to buttons
     *
     * @param mixed $data The HTTP value
     */
    private function submitToButtons($data): void
    {
        $this->submitButton = null;

        foreach ($this->buttons as $button) {
            if ($button->submit($data) && $this->submitButton === null) {
                $this->submitButton = $button;
            }
        }
    }
}


1		<?php
2
3		namespace Bdf\Form\Aggregate;
4
5		use BadMethodCallException;
6		use Bdf\Form\Button\ButtonInterface;
7		use Bdf\Form\Child\ChildInterface;
8		use Bdf\Form\Child\Http\HttpFieldPath;
9		use Bdf\Form\ElementInterface;
10		use Bdf\Form\Error\FormError;
11		use Bdf\Form\RootElementInterface;
12		use Bdf\Form\View\ElementViewInterface;
13		use Iterator;
14		use OutOfBoundsException;
15		use Symfony\Component\PropertyAccess\PropertyAccess;
16		use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
17		use Symfony\Component\Validator\Constraint;
18		use Symfony\Component\Validator\Validator\ValidatorInterface;
19		use Symfony\Component\Validator\ValidatorBuilder;
20		use WeakReference;
21
22		/**
23		* Adapt a form element as root element
24		* The root form handle constraint group, validator and property accessor instances, and submit button
25		*
26		* The root form should be used instead of the form element for `submit()`
27		*
28		* <code>
29		* $form = new MyForm();
30		*
31		* $root = $form->root();
32		* if (!$root->submit($request->post())->valid()) {
33		* throw new MyError();
34		* }
35		*
36		* $entity = $root->value();
37		*
38		* switch ($btn = $root->submitButton() ? $btn->name() : null) {
39		* case 'save':
40		* return $this->save($entity);
41		*
42		* case 'delete':
43		* return $this->delete($entity);
44		*
45		* default:
46		* throw new InvalidAction();
47		* }
48		* </code>
49		*
50		* @todo delegation trait
51		*/
52		final class RootForm implements RootElementInterface, ChildAggregateInterface
53		{
54		/**
55		* @var WeakReference<Form>
56		*/
57		private $form;
58
59		/**
60		* @var array<non-empty-string, ButtonInterface>
		0 ignored issues – show Documentation Bug introduced 2021-12-09 11:49 UTC by Report Bug Copy Issue Report The doc comment `array<non-empty-string, ButtonInterface>` at position `2` could not be parsed: Unknown type name 'non-empty-string' at position 2 in array<non-empty-string, ButtonInterface>. Loading history...
61		*/
62		private $buttons;
63
64		/**
65		* @var ButtonInterface\|null
66		*/
67		private $submitButton;
68
69		/**
70		* @var PropertyAccessorInterface\|null
71		*/
72		private $propertyAccessor;
73
74		/**
75		* @var ValidatorInterface\|null
76		*/
77		private $validator;
78
79
80		/**
81		* RootForm constructor.
82		*
83		* @param Form $form
84		* @param array<non-empty-string, ButtonInterface> $buttons Buttons, indexed by there name
		0 ignored issues – show Documentation Bug introduced 2021-12-09 11:49 UTC by Report Bug Copy Issue Report The doc comment `array<non-empty-string, ButtonInterface>` at position `2` could not be parsed: Unknown type name 'non-empty-string' at position 2 in array<non-empty-string, ButtonInterface>. Loading history...
85		* @param PropertyAccessorInterface\|null $propertyAccessor
86		* @param ValidatorInterface\|null $validator
87		*/
88	149	public function __construct(Form $form, array $buttons = [], ?PropertyAccessorInterface $propertyAccessor = null, ?ValidatorInterface $validator = null)
89		{
90	149	$this->form = WeakReference::create($form);
91	149	$this->buttons = $buttons;
92	149	$this->propertyAccessor = $propertyAccessor;
93	149	$this->validator = $validator;
94	149	}
95
96		/**
97		* {@inheritdoc}
98		*/
99	27	public function submit($data): ElementInterface
100		{
101	27	$this->submitToButtons($data);
102		/** @psalm-suppress PossiblyNullReference */
103	27	$this->form->get()->submit($data);
104
105	27	return $this;
106		}
107
108		/**
109		* {@inheritdoc}
110		*/
111	3	public function patch($data): ElementInterface
112		{
113	3	$this->submitToButtons($data);
114		/** @psalm-suppress PossiblyNullReference */
115	3	$this->form->get()->patch($data);
116
117	3	return $this;
118		}
119
120		/**
121		* {@inheritdoc}
122		*/
123	2	public function import($entity): ElementInterface
124		{
125		/** @psalm-suppress PossiblyNullReference */
126	2	$this->form->get()->import($entity);
127
128	2	return $this;
129		}
130
131		/**
132		* {@inheritdoc}
133		*/
134	1	public function value()
135		{
136		/** @psalm-suppress PossiblyNullReference */
137	1	return $this->form->get()->value();
138		}
139
140		/**
141		* {@inheritdoc}
142		*/
143	2	public function httpValue()
144		{
145		/** @psalm-suppress PossiblyNullReference */
146	2	$httpValue = $this->form->get()->httpValue();
147
148	2	if (empty($this->buttons)) {
149	1	return $httpValue;
150		}
151
152	1	$httpValue = (array) $httpValue;
153
154	1	foreach ($this->buttons as $btn) {
155	1	$httpValue += $btn->toHttp();
156		}
157
158	1	return $httpValue;
159		}
160
161		/**
162		* {@inheritdoc}
163		*/
164	1	public function valid(): bool
165		{
166		/** @psalm-suppress PossiblyNullReference */
167	1	return $this->form->get()->valid();
168		}
169
170		/**
171		* {@inheritdoc}
172		*/
173	1	public function error(?HttpFieldPath $field = null): FormError
174		{
175		/** @psalm-suppress PossiblyNullReference */
176	1	return $this->form->get()->error($field);
177		}
178
179		/**
180		* {@inheritdoc}
181		*/
182	2	public function container(): ?ChildInterface
183		{
184	2	return null; // root cannot have a container
185		}
186
187		/**
188		* {@inheritdoc}
189		*/
190	1	public function setContainer(ChildInterface $container): ElementInterface
191		{
192	1	throw new BadMethodCallException('Cannot wrap a root element into a container');
193		}
194
195		/**
196		* {@inheritdoc}
197		*/
198	1	public function root(): RootElementInterface
199		{
200	1	return $this;
201		}
202
203		/**
204		* {@inheritdoc}
205		*/
206	5	public function view(?HttpFieldPath $field = null): ElementViewInterface
207		{
208	5	$buttons = [];
209
210	5	foreach ($this->buttons as $button) {
211	2	$buttons[$button->name()] = $button->view($field);
212		}
213
214		/** @psalm-suppress PossiblyNullReference */
215	5	$view = $this->form->get()->view($field);
216	5	$view->setButtons($buttons);
217
218	5	return $view;
219		}
220
221		/**
222		* {@inheritdoc}
223		*/
224	4	public function submitButton(): ?ButtonInterface
225		{
226	4	return $this->submitButton;
227		}
228
229		/**
230		* {@inheritdoc}
231		*/
232	2	public function button(string $name): ButtonInterface
233		{
234	2	if ($btn = $this->buttons[$name] ?? null) {
235	1	return $btn;
236		}
237
238	1	throw new OutOfBoundsException("The button '{$name}' is not found");
239		}
240
241		/**
242		* {@inheritdoc}
243		*/
244	68	public function getValidator(): ValidatorInterface
245		{
246	68	if ($this->validator === null) {
247	67	$this->validator = (new ValidatorBuilder())->getValidator();
248		}
249
250	68	return $this->validator;
251		}
252
253		/**
254		* {@inheritdoc}
255		*/
256	79	public function getPropertyAccessor(): PropertyAccessorInterface
257		{
258	79	if ($this->propertyAccessor === null) {
259	78	$this->propertyAccessor = PropertyAccess::createPropertyAccessor();
260		}
261
262	79	return $this->propertyAccessor;
263		}
264
265		/**
266		* {@inheritdoc}
267		*/
268	66	public function constraintGroups(): array
269		{
270	66	if (!$button = $this->submitButton) {
271	65	return [Constraint::DEFAULT_GROUP];
272		}
273
274	2	return $button->constraintGroups() ?: [Constraint::DEFAULT_GROUP];
275		}
276
277		/**
278		* {@inheritdoc}
279		*
280		* @psalm-suppress InvalidNullableReturnType
281		* @psalm-suppress PossiblyNullReference
282		* @psalm-suppress PossiblyNullArrayAccess
283		* @psalm-suppress NullableReturnStatement
284		*/
285	6	public function offsetGet($offset): ChildInterface
286		{
287	6	return $this->form->get()[$offset];
288		}
289
290		/**
291		* {@inheritdoc}
292		*/
293	4	public function offsetExists($offset): bool
294		{
295		/** @psalm-suppress PossiblyNullReference */
296	4	return isset($this->form->get()[$offset]);
297		}
298
299		/**
300		* {@inheritdoc}
301		*/
302		public function offsetSet($offset, $value): void
303		{
304		/** @psalm-suppress PossiblyNullReference */
305		$this->form->get()[$offset] = $value;
306		}
307
308		/**
309		* {@inheritdoc}
310		*
311		* @psalm-suppress PossiblyNullReference
312		* @psalm-suppress PossiblyNullArrayAccess
313		*/
314		public function offsetUnset($offset): void
315		{
316		unset($this->form->get()[$offset]);
317		}
318
319		/**
320		* {@inheritdoc}
321		*/
322		public function getIterator(): Iterator
323		{
324		/** @psalm-suppress PossiblyNullReference */
325		return $this->form->get()->getIterator();
326		}
327
328		/**
329		* Submit HTTP fields to buttons
330		*
331		* @param mixed $data The HTTP value
332		*/
333	28	private function submitToButtons($data): void
334		{
335	28	$this->submitButton = null;
336
337	28	foreach ($this->buttons as $button) {
338	4	if ($button->submit($data) && $this->submitButton === null) {
339	4	$this->submitButton = $button;
340		}
341		}
342	28	}
343		}
344

b2pweb / bdf-form

Pull Request — master (#3)

RootForm::view() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like