Ngtfkx\Laradeck\FormBuilder\Elements\AbstractElement

Complexity

Total Complexity

55

Size/Duplication

Total Lines	410
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

28 Methods

Rating	Name	Duplication	Size	Complexity
	tag()	0	1	?
A	__construct()	0	12	1
A	layout()	0	6	1
A	label()	0	6	1
A	help()	0	6	1
A	value()	0	6	1
A	id()	0	6	1
A	name()	0	6	1
A	class()	0	6	1
A	classes()	0	10	3
B	style()	0	17	5
A	styles()	0	8	2
A	attr()	0	6	1
A	attrs()	0	14	4
A	clearClasses()	0	6	1
A	clearStyles()	0	6	1
A	clearAttributes()	0	6	1
B	render()	0	25	4
A	getTagHtml()	0	4	1
A	beforeToParts()	0	8	3
A	afterToParts()	0	4	1
A	__toString()	0	14	1
B	generateAttributes()	0	14	6
A	stylesToParts()	0	13	3
A	classesToParts()	0	6	2
A	attributesToParts()	0	6	2
A	addAttr()	0	10	3
A	addAttrAs()	0	10	3

<?php

namespace Ngtfkx\Laradeck\FormBuilder\Elements;


use Illuminate\Support\Collection;
use Ngtfkx\Laradeck\FormBuilder\Layouts\AbstractLayout;

abstract class AbstractElement
{
    /**
     * @var Collection|iterable $classes Коллекция классом элемента
     */
    protected $classes;

    /**
     * @var Collection|iterable $attributes Коллекция дополнительных атрибутов элемента
     */
    protected $attributes;

    /**
     * @var Collection|iterable $styles Коллекция inline-стилей элемента
     */
    protected $styles;

    /**
     * @var string $value Значение элемента
     */
    protected $value;

    /**
     * @var string $tag Тег элемента
     */
    protected $tag;

    /**
     * @var Collection|iterable $parts Набор атрибутов для генерации html-кода элементов
     */
    protected $parts;

    /**
     * @var string $label
     */
    protected $label;

    /**
     * @var string $help
     */
    protected $help;

    /**
     * @var AbstractLayout
     */
    protected $layout;

    protected $onlyTagRender = false;

    /**
     * @return void
     */
    abstract public function tag();

    public function __construct()
    {
        $this->classes = new Collection();

        $this->attributes = new Collection();

        $this->styles = new Collection();

        $this->parts = new Collection();

        $this->tag();
    }

    public function layout(?AbstractLayout $layout): self
    {
        $this->layout = $layout;

        return $this;
    }

    /**
     * Сеттер значения лейбла для элемента
     *
     * @param string|null $value
     * @return AbstractElement
     */
    public function label(?string $value): self
    {
        $this->label = $value;

        return $this;
    }

    /**
     * Сеттер значения подсказки для элемента
     *
     * @param string|null $value
     * @return AbstractElement
     */
    public function help(?string $value): self
    {
        $this->help = $value;

        return $this;
    }

    /**
     * Сеттер значения элемента
     *
     * @param string|null $value
     * @return AbstractElement
     */
    public function value(?string $value): self
    {
        $this->value = $value;

        return $this;
    }

    /**
     * Сеттер атрибута id элемента
     *
     * @param string|null $value
     * @return AbstractElement
     */
    public function id(?string $value): self
    {
        $this->attr('id', $value);

        return $this;
    }

    /**
     * Сеттер атрибута name элемента
     *
     * @param string|null $value
     * @return AbstractElement
     */
    public function name(?string $value): self
    {
        $this->attr('name', $value);

        return $this;
    }

    /**
     * Добавить элементу один или несколько классов
     *
     * @param array ...$classes
     * @return AbstractElement
     */
    public function class(...$classes): self

Possible parse error: non-abstract method defined as abstract

It is generally advisable to only define one property per statement.

    {
        $this->classes($classes);

$classes is of type array<integer,array>, but the function expects a object<Ngtfkx\Laradeck\FormBuilder\Elements\iterable>.

        return $this;

The visibility should be declared for property $this.

    }

    /**
     *  Добавить элементу один или несколько классов из массива
     *
     * @param iterable $classes
     * @return AbstractElement
     */
    public function classes(iterable $classes): self
    {
        foreach ($classes as $class) {
            if (!$this->classes->contains($class)) {
                $this->classes->push($class);
            }
        }

        return $this;
    }

    /**
     * Добавить к элементу один или несколько inline-стилей
     *
     * @param string $key
     * @param string|null $value
     * @return AbstractElement
     */
    public function style(string $key, string $value = null): self
    {
        if (empty($value)) {
            $pos = strpos($key, ':', 2);
            if ($pos !== false) {
                $parts = explode(':', strrev($key));
                $key = strrev($parts[1]);
                $value = strrev($parts[0]);
            }
        }

        if ($key && $value) {

The expression $value of type null|string is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $this->styles->put($key, $value);
        }

        return $this;
    }

    /**
     * Добавить к элементу один или несколько inline-стилей из массива
     *
     * @param iterable $styles
     * @return AbstractElement
     */
    public function styles(iterable $styles): self
    {
        foreach ($styles as $key => $value) {
            $this->styles->put($key, $value);
        }

        return $this;
    }

    /**
     * Добавить аттрибут к элементу
     *
     * @param string $key
     * @param string|null $value
     * @return AbstractElement
     */
    public function attr(string $key, $value = null): self
    {
        $this->attributes->put($key, $value);

        return $this;
    }

    /**
     * Добавить один или несколько атрибутов из массива к элементу
     *
     * @param iterable $attributes
     * @return AbstractElement
     */
    public function attrs(iterable $attributes): self
    {
        foreach ($attributes as $key => $value) {
            if ($key === 'class') {
                $this->class($value);
            } else if ($key === 'style') {
                $this->style($value);
            } else {
                $this->attributes->put($key, $value);
            }
        }

        return $this;
    }

    /**
     * Очистить классы элемента
     *
     * @return AbstractElement
     */
    public function clearClasses(): self
    {
        $this->classes = new Collection();

        return $this;
    }

    /**
     * Очистить классы стили
     *
     * @return AbstractElement
     */
    public function clearStyles(): self
    {
        $this->styles = new Collection();

        return $this;
    }

    /**
     * Очистить классы атрибуты
     *
     * @return AbstractElement
     */
    public function clearAttributes(): self
    {
        $this->attributes = new Collection();

        return $this;
    }

    protected function render(): string
    {
        $attributes = $this->generateAttributes();

        $tag = $this->getTagHtml();

        $tag = str_replace('**attributes**', $attributes, $tag);

        if (is_null($this->layout) === false) {
            $view = 'fb::' . $this->layout->getViewsDirPath() . '.base';

            if(view()->exists($view) && $this->onlyTagRender === false) {
                $data = [
                    'id' => 'idddd',
                    'help' => 'ggggggggggg',
                    'label' => '45345345',
                    'tag' => $tag,
                ];

                return view($view, $data);
            }
        }

        return $tag;
    }

    protected function getTagHtml()
    {
        return '<' . $this->tag . '**attributes**>';
    }

    protected function beforeToParts(): void
    {
        $this->addAttr('value');

        if (is_null($this->layout) === false && $this->layout->getElementClasses()) {
            $this->class($this->layout->getElementClasses());
        }
    }

    protected  function afterToParts(): void
    {

    }

    /**
     * Преобразовать в строку для вывода в HTML
     *
     * @return string
     */
    public function __toString(): string
    {
        $this->beforeToParts();

        $this->classesToParts();

        $this->stylesToParts();

        $this->attributesToParts();

        $this->afterToParts();

        return $this->render();
    }

    protected function generateAttributes(): string
    {
        $attributes = '';

        foreach ($this->parts as $key => $value) {
            if (is_null($value) || (is_bool($value) && $value === false)) {
                continue;
            }

            $attributes .= ' ' . $key . '="' . (is_bool($value) ? $key : $value) . '"';
        }

        return $attributes;
    }

    protected function stylesToParts(): void
    {
        if ($this->styles->isNotEmpty()) {
            $this->parts->put('style', $this->styles->pipe(function ($styles) {
                $styleAttr = '';
                foreach ($styles as $key => $value) {
                    $styleAttr .= $key . ':' . $value . ';';
                }

                return $styleAttr;
            }));
        }
    }

    protected function classesToParts(): void
    {
        if ($this->classes->isNotEmpty()) {
            $this->parts->put('class', $this->classes->implode(' '));
        }
    }

    public function attributesToParts(): void
    {
        foreach ($this->attributes as $key => $value) {
            $this->parts->put($key, $value);
        }
    }

    protected function addAttr(...$names): self
    {
        foreach ($names as $name) {
            if (!empty($this->$name)) {
                $this->parts[$name] = $this->$name;
            }
        }

        return $this;
    }

    protected function addAttrAs(...$names): self
    {
        foreach ($names as $name) {
            if (!empty($this->$name)) {
                $this->parts[$name] = $name;
            }
        }

        return $this;
    }
}