drupol\htmltag\Attribute\Attribute

Complexity

Total Complexity

25

Size/Duplication

Total Lines	249
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes

0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	offsetExists()	0	4	1
A	offsetGet()	0	4	1
A	offsetSet()	0	4	1
A	offsetUnset()	0	4	1
A	set()	0	6	1
A	getName()	0	4	1
A	getValuesAsArray()	0	6	1
A	render()	0	8	2
A	sanitize()	0	4	1
A	__toString()	0	4	1
A	isBoolean()	0	4	1
A	append()	0	6	1
A	remove()	0	9	1
A	replace()	0	12	2
A	contains()	0	15	1
A	setBoolean()	0	6	2
A	delete()	0	7	1
A	alter()	0	13	2
A	serialize()	0	7	1
A	unserialize()	0	7	1

<?php

namespace drupol\htmltag\Attribute;

use drupol\htmltag\AbstractBaseHtmlTagObject;

/**
 * Class Attribute.
 */
class Attribute extends AbstractBaseHtmlTagObject implements AttributeInterface
{
    /**
     * Store the attribute name.
     *
     * @var string|null
     */
    private $name;

    /**
     * Store the attribute value.
     *
     * @var array|null
     */
    private $values;

    /**
     * Attribute constructor.
     *
     * @param string $name
     *   The attribute name.
     * @param string|string[]|mixed[] ...$values
     *   The attribute values.
     */
    public function __construct($name, ...$values)
    {
        $this->name = $name;
        $this->values = array_filter($values);
    }

    /**
     * {@inheritdoc}
     */
    public function offsetExists($offset)
    {
        return $this->contains($offset);
    }
    /**
     * {@inheritdoc}
     */
    public function offsetGet($offset)
    {
        throw new \BadMethodCallException('Unsupported method.');
    }

    /**
     * {@inheritdoc}
     */
    public function offsetSet($offset, $value)
    {
        $this->append($value);
    }

    /**
     * {@inheritdoc}
     */
    public function offsetUnset($offset)
    {
        $this->remove($offset);
    }

    /**
     * {@inheritdoc}
     */
    public function set(...$value)
    {
        $this->values = $value;

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function getName()
    {
        return \trim($this->sanitize($this->name));
    }

    /**
     * {@inheritdoc}
     */
    public function getValuesAsArray()
    {
        $name = $this->getName();

        return $this->preprocess($this->normalizeValue($this->values), $name);
    }

    /**
     * {@inheritdoc}
     */
    public function render()
    {
        $values = $this->getValuesAsArray();

        return empty($values) ?
            $this->getName() :
            $this->getName() . '="' . $this->sanitize(\implode(' ', $values)) . '"';
    }

    /**
     * Sanitize a value.
     *
     * @param string|null $value
     *   The value to sanitize
     *
     * @return string
     *   The value sanitized.
     */
    protected function sanitize($value)
    {
        return htmlspecialchars((string) $value, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8');
    }

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

    /**
     * {@inheritdoc}
     */
    public function isBoolean()
    {
        return [] === $this->getValuesAsArray();
    }

    /**
     * {@inheritdoc}
     */
    public function append(...$value)
    {
        $this->values[] = $value;

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function remove(...$value)
    {
        return $this->set(
            \array_diff(
                $this->normalizeValue($this->values),
                $this->normalizeValue($value)
            )
        );
    }

    /**
     * {@inheritdoc}
     */
    public function replace($original, ...$replacement)
    {
        $count_start = \count($this->normalizeValue($this->values));
        $this->remove($original);
        $count_end = \count($this->normalizeValue($this->values));

        if ($count_end !== $count_start) {
            $this->append($replacement);
        }

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function contains(...$substring)
    {
        $values = $this->normalizeValue($this->values);

        return !in_array(
            false,
            \array_map(
                function ($substring_item) use ($values) {
                    return \in_array($substring_item, $values, true);
                },
                $this->normalizeValue($substring)
            ),
            true
        );
    }

    /**
     * {@inheritdoc}
     */
    public function setBoolean($boolean = true)
    {
        return true === $boolean ?
            $this->set(null) :
            $this;
    }

    /**
     * {@inheritdoc}
     */
    public function delete()
    {
        $this->name = null;
        $this->values = null;

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function alter(callable ...$closures)
    {
        $name = $this->getName();

        foreach ($closures as $closure) {
            $this->values = $closure(
                $this->normalizeValue($this->values),
                $name
            );
        }

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function serialize()
    {
        return \serialize([
            'name' => $this->getName(),
            'values' => $this->getValuesAsArray(),
        ]);
    }

    /**
     * {@inheritdoc}
     */
    public function unserialize($serialized)
    {
        $unserialized = \unserialize($serialized);

        $this->name = $unserialized['name'];
        $this->values = $unserialized['values'];
    }
}