FlexPHP\Inputs\Builder\AbstractBuilder

Complexity

Total Complexity

32

Size/Duplication

Total Lines	180
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	render()	0	4	1
A	factory()	0	3	1
A	twig()	0	23	1
A	getName()	0	3	1
A	__construct()	0	4	1
A	getDefaultOptions()	0	7	1
A	getOptions()	0	3	1
F	parseOptions()	0	83	20
A	build()	0	25	5

<?php

namespace FlexPHP\Inputs\Builder;

use Symfony\Component\Form\Extension\Core\Type\FormType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\Form\Forms;
use Symfony\Component\Form\FormInterface;
use \InvalidArgumentException;

abstract class AbstractBuilder implements BuilderInterface
{
    private $name;
    private $options;
    protected $type;

    public function __construct(string $name, array $options)
    {
        $this->name = $name;
        $this->options = $this->parseOptions($this->getDefaultOptions($options));
    }

    abstract protected function getType(): string;

    public function getName(): string
    {
        return preg_replace('/(\s)+/', '_', trim($this->name)) ?? $this->name;
    }

    public function getOptions(): array
    {
        return $this->options;
    }

    public function build(): FormInterface
    {
        $options = $this->getOptions();
        $classType = trim($this->getType());

        if (\strpos($classType, 'Symfony') === false) {
            // Not symfony type
            $type = preg_replace('/type$/i', '', $classType) ?? $classType;
            $classType = \sprintf('\Symfony\Component\Form\Extension\Core\Type\%1$sType', \ucwords($type));
        } elseif (!empty($options['type']) && strpos(\strtolower($classType), $options['type']) === false) {
            // Symfony type, but its diff in options type contraint
            $type = $options['type'];
            $classType = \sprintf('\Symfony\Component\Form\Extension\Core\Type\%1$sType', \ucwords($type));
        }

        unset($options['type']);

        if (!\class_exists($classType)) {
            throw new InvalidArgumentException(\sprintf('Type [%1$s] is not supported', $classType));
        }

        return $this
            ->factory()
            ->add($this->getName(), $classType, $options)
            ->getForm();
    }

    public function render(): string
    {
        return $this->twig()->createTemplate(\sprintf('{{ form_row(form.%1$s) }}', $this->getName()))->render([
            'form' => $this->build()->createView(),
        ]);
    }

    protected function factory(): FormBuilderInterface
    {
        return Forms::createFormFactory()->createBuilder(FormType::class, null);
    }

    protected function getDefaultOptions(array $options = []): array
    {
        return array_merge([
            'mapped' => false,
            'required' => false,
            'trim' => false,
        ], $options);
    }

    private function parseOptions(array $options): array
    {
        $_options = [];

        $options = array_change_key_case(array_filter($options, function ($var) {
            return !is_null($var);
        }));

        if (!empty($options['attr']['type'])) {
            $options['type'] = $options['attr']['type'];
            unset($options['attr']['type']);
        }

        if (!empty($options['constraints']['type'])) {
            $options['type'] = $options['constraints']['type'];
            unset($options['constraints']['type']);
        }

        foreach ($options as $option => $value) {
            switch ($option) {
                case 'default':
                    $_options['data'] = $value;
                    break;
                case 'constraints':
                    $attributes = \json_decode($value, true);

                    if ((\json_last_error() !== JSON_ERROR_NONE)) {
                        $attributes = [$value];
                    }

                    foreach ($attributes as $attribute => $_value) {
                        $attribute = \strtolower($attribute);

                        if ($attribute == 'required' || $_value == 'required') {
                            $_options['required'] = true;
                        } elseif (in_array($attribute, ['length', 'mincheck', 'maxcheck', 'check', 'equalto'])) {
                            $_options['attr']['data-parsley-' . $attribute] = $_value;
                        } elseif ($attribute == 'range') {
                            $_options['type'] = $attribute;
                            list($min, $max) = explode(',', $_value);
                            $_options['attr'] = compact('min', 'max');
                        } elseif ($attribute == 'type') {
                            $_options['type'] = $_value;
                        } else {
                            $_options['attr'][$attribute] = $_value;
                        }
                    }
                    break;
                case 'empty_data':
                    $_options[$option] = $value;

                    if (empty($_options['attr'])) {
                        $_options['attr'] = [];
                    }

                    $_options['attr']['placeholder'] = $value;

                    break;
                default:
                    if (is_array($value) && !empty($_options[$option])) {
                        $_options[$option] = array_merge_recursive($_options[$option], $value);
                    } else {
                        $_options[$option] = $value;
                    }
                    break;
            }

            unset($options[$option]);
        }

        if (!empty($_options['type'])) {
            $_type = strtolower($_options['type']);

            switch ($_type) {
                case 'digits':
                case 'alphanum':
                    $_options['attr']['data-parsley-type'] = $_type;
                    $_options['type'] = 'text';
                    break;
            }
        }

        return $_options;
    }

    private function twig()
    {
        $appVariableReflection = new \ReflectionClass('\Symfony\Bridge\Twig\AppVariable');
        $vendorTwigBridgeDirectory = dirname((string)$appVariableReflection->getFileName());

        $loader = new \Twig\Loader\FilesystemLoader([
            $vendorTwigBridgeDirectory . '/Resources/views/Form',
        ]);

        $twig = new \Twig\Environment($loader);
        $twig->addExtension(new \Symfony\Bridge\Twig\Extension\FormExtension());
        $twig->addExtension(new \Symfony\Bridge\Twig\Extension\TranslationExtension(
            new \Symfony\Component\Translation\Translator('en')
        ));

        $formEngine = new \Symfony\Bridge\Twig\Form\TwigRendererEngine(['bootstrap_4_layout.html.twig'], $twig);
        $twig->addRuntimeLoader(new \Twig\RuntimeLoader\FactoryRuntimeLoader([
            \Symfony\Component\Form\FormRenderer::class => function () use ($formEngine) {
                return new \Symfony\Component\Form\FormRenderer($formEngine);
            },
        ]));

        return $twig;
    }
}