Bdf\Form\Aggregate\RootForm

Complexity

Total Complexity

32

Size/Duplication

Total Lines	257
Duplicated Lines	0 %

Test Coverage

Coverage

86.67%

Importance

Changes	1
Bugs	0	Features	0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	submit()	0	6	1
A	patch()	0	6	1
A	import()	0	5	1
A	value()	0	3	1
A	root()	0	3	1
A	offsetSet()	0	3	1
A	offsetGet()	0	3	1
A	submitButton()	0	3	1
A	httpValue()	0	15	3
A	valid()	0	3	1
A	getValidator()	0	7	2
A	constraintGroups()	0	7	3
A	getIterator()	0	3	1
A	container()	0	3	1
A	offsetExists()	0	3	1
A	setContainer()	0	3	1
A	view()	0	12	2
A	submitToButtons()	0	7	4
A	getPropertyAccessor()	0	7	2
A	error()	0	3	1
A	offsetUnset()	0	3	1

<?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 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;

/**
 * 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 Form
     */
    private $form;

    /**
     * @var ButtonInterface[]
     */
    private $buttons;

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

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

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


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

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

        return $this;
    }

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

        return $this;
    }

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

        return $this;
    }

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

    /**
     * {@inheritdoc}
     */
    public function httpValue()
    {
        $httpValue = $this->form->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
    {
        return $this->form->valid();
    }

    /**
     * {@inheritdoc}
     */
    public function error(?HttpFieldPath $field = null): FormError
    {
        return $this->form->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);
        }

        $view = $this->form->view($field);
        $view->setButtons($buttons);

        return $view;
    }

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

    /**
     * {@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}
     */
    public function offsetGet($offset): ChildInterface
    {
        return $this->form[$offset];
    }

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

    /**
     * {@inheritdoc}
     */
    public function offsetSet($offset, $value)
    {
        $this->form[$offset] = $value;
    }

    /**
     * {@inheritdoc}
     */
    public function offsetUnset($offset)
    {
        unset($this->form[$offset]);
    }

    /**
     * {@inheritdoc}
     */
    public function getIterator()
    {
        return $this->form->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;
            }
        }
    }
}