AppUtils\HTMLTag

Complexity

Total Complexity

44

Size/Duplication

Total Lines	317
Duplicated Lines	0 %

Importance

Changes	5
Bugs	0	Features	0

33 Methods

Rating	Name	Duplication	Size	Complexity
A	__toString()	0	3	1
A	setSelfClosing()	0	4	1
A	getSelfClosingChar()	0	8	3
A	create()	0	8	2
A	addText()	0	4	1
A	__construct()	0	5	1
A	isEmptyAllowed()	0	8	2
A	getGlobalOptions()	0	8	2
A	getName()	0	3	1
A	setEmptyAllowed()	0	4	1
A	renderClose()	0	8	2
A	setContent()	0	4	1
A	render()	0	11	3
A	isEmpty()	0	3	2
A	hasAttributes()	0	3	1
A	renderContent()	0	8	2
A	isSelfClosing()	0	3	1
A	addHTML()	0	4	1
A	renderOpen()	0	7	1
A	name()	0	4	1
A	addClass()	0	4	1
A	id()	0	4	1
A	removeClass()	0	4	1
A	classesToAttribute()	0	3	1
A	prop()	0	4	1
A	addClasses()	0	4	1
A	getClasses()	0	3	1
A	classesToString()	0	3	1
A	hasClass()	0	3	1
A	src()	0	4	1
A	hasClasses()	0	3	1
A	href()	0	4	1
A	attr()	0	9	2

<?php
/**
 * File containing the class {@see \AppUtils\HTMLTag}.
 *
 * @package AppUtils
 * @subpackage HTML
 * @see \AppUtils\HTMLTag
 */

declare(strict_types=1);

namespace AppUtils;

use AppUtils\HTMLTag\GlobalOptions;

/**
 * Helper class for generating individual HTML tags,
 * with chainable methods.
 *
 * @package AppUtils
 * @subpackage HTML
 * @author Sebastian Mordziol <s.mordziol@mistralys.eu>
 *
 * @link https://github.com/Mistralys/application-utils/wiki/HTMLTag
 */
class HTMLTag implements Interface_Stringable, Interface_Classable
{
    public const SELF_CLOSE_STYLE_SLASH = 'slash';
    public const SELF_CLOSE_STYLE_NONE = 'none';

    public AttributeCollection $attributes;
    private string $name;
    public StringBuilder $content;
    private bool $selfClosing = false;
    private bool $allowEmpty = false;
    private static ?GlobalOptions $globalOptions = null;

    private function __construct(string $name, AttributeCollection $attributes)
    {
        $this->name = $name;
        $this->attributes = $attributes;
        $this->content = sb();
    }

    /**
     * @return string
     */
    public function getName() : string
    {
        return $this->name;
    }

    /**
     * @param bool $selfClosing
     * @return $this
     */
    public function setSelfClosing(bool $selfClosing=true) : self
    {
        $this->selfClosing = $selfClosing;
        return $this;
    }

    public function isSelfClosing() : bool
    {
        return $this->selfClosing;
    }

    /**
     * @param bool $allowed
     * @return $this
     */
    public function setEmptyAllowed(bool $allowed=true) : self
    {
        $this->allowEmpty = $allowed;
        return $this;
    }

    public function isEmptyAllowed() : bool
    {
        if($this->isSelfClosing())
        {
            return true;
        }

        return $this->allowEmpty;
    }

    public static function create(string $name, ?AttributeCollection $attributes=null) : HTMLTag
    {
        if($attributes === null)
        {
            $attributes = AttributeCollection::create();
        }

        return new HTMLTag($name, $attributes);
    }

    public function hasAttributes() : bool
    {
        return $this->attributes->hasAttributes();
    }

    /**
     * Returns true if the tag has no content, and no attributes.
     * By default, an empty tag is not rendered.
     *
     * @return bool
     */
    public function isEmpty() : bool
    {
        return !$this->hasAttributes() && $this->renderContent() === '';
    }

    public function render() : string
    {
        if(!$this->isEmptyAllowed() && $this->isEmpty())
        {
            return '';
        }

        return
            $this->renderOpen().
            $this->renderContent().
            $this->renderClose();
    }

    public static function getGlobalOptions() : GlobalOptions
    {
        if(!isset(self::$globalOptions))
        {
            self::$globalOptions = new GlobalOptions();
        }

        return self::$globalOptions;

The expression return self::globalOptions could return the type null which is incompatible with the type-hinted return AppUtils\HTMLTag\GlobalOptions. Consider adding an additional type-check to rule them out.

    }

    public function getSelfClosingChar() : string
    {
        if($this->selfClosing && self::getGlobalOptions()->getSelfCloseStyle() === self::SELF_CLOSE_STYLE_SLASH)
        {
            return '/';
        }

        return '';
    }

    public function renderOpen() : string
    {
        return sprintf(
            '<%s%s%s>',
            $this->name,
            $this->attributes,
            $this->getSelfClosingChar()
        );
    }

    public function renderClose() : string
    {
        if($this->selfClosing)
        {
            return '';
        }

        return sprintf('</%s>', $this->name);
    }

    /**
     * Adds a bit of text to the content (with an automatic space at the end).
     *
     * @param string|number|StringBuilder_Interface|NULL $content
     * @return $this
     */
    public function addText($content) : self
    {
        $this->content->add($content);
        return $this;
    }

    /**
     * Adds a bit of HTML at the end of the content.
     *
     * @param string|number|StringBuilder_Interface|NULL $content
     * @return $this
     */
    public function addHTML($content) : self
    {
        $this->content->html($content);
        return $this;
    }

    /**
     * @param string|number|Interface_Stringable|NULL $content
     * @return $this
     */
    public function setContent($content) : self
    {
        $this->content = sb()->add($content);
        return $this;
    }

    public function renderContent() : string
    {
        if($this->selfClosing)
        {
            return '';
        }

        return (string)$this->content;
    }

    public function __toString()
    {
        return $this->render();
    }

    /**
     * @param string $name
     * @param string $value
     * @param bool $keepIfEmpty
     * @return $this
     */
    public function attr(string $name, string $value, bool $keepIfEmpty=false) : self
    {
        $this->attributes->attr($name, $value);

        if($keepIfEmpty) {
            $this->attributes->setKeepIfEmpty($name);
        }

        return $this;
    }

    /**
     * @param string $name
     * @param bool $enabled
     * @return $this
     */
    public function prop(string $name, bool $enabled=true) : self
    {
        $this->attributes->prop($name, $enabled);
        return $this;
    }

    // region: Flavors

    /**
     * @param string $name
     * @return $this
     */
    public function name(string $name) : self
    {
        $this->attributes->name($name);
        return $this;
    }

    /**
     * @param string $id
     * @return $this
     */
    public function id(string $id) : self
    {
        $this->attributes->id($id);
        return $this;
    }

    /**
     * @param string $url
     * @return $this
     */
    public function href(string $url) : self
    {
        $this->attributes->href($url);
        return $this;
    }

    /**
     * @param string $url
     * @return $this
     */
    public function src(string $url) : self
    {
        $this->attributes->attrURL('src', $url);
        return $this;
    }

    // endregion

    // region: Classable interface

    /**
     * @param string $name
     * @return $this
     */
    public function addClass($name) : self
    {
        $this->attributes->addClass($name);
        return $this;
    }

    /**
     * @param string[] $names
     * @return $this
     */
    public function addClasses(array $names) : self
    {
        $this->attributes->addClasses($names);
        return $this;
    }

    public function hasClass(string $name) : bool
    {
        return $this->attributes->hasClass($name);
    }

    /**
     * @param string $name
     * @return $this
     */
    public function removeClass(string $name) : self
    {
        $this->attributes->removeClass($name);
        return $this;
    }

    public function getClasses() : array
    {
        return $this->attributes->getClasses();
    }

    public function classesToString() : string
    {
        return $this->attributes->classesToString();
    }

    public function classesToAttribute() : string
    {
        return $this->attributes->classesToAttribute();
    }

    public function hasClasses() : bool
    {
        return $this->attributes->hasClasses();
    }

    // endregion
}