drupol\htmltag\Attributes\Attributes

Complexity

Total Complexity

37

Size/Duplication

Total Lines	307
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

99.02%

Importance

Changes

0

24 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	import()	0	8	2
A	set()	0	6	1
A	offsetGet()	0	8	2
A	offsetSet()	0	4	1
A	offsetUnset()	0	4	1
A	offsetExists()	0	4	1
A	append()	0	10	1
A	remove()	0	8	2
A	delete()	0	8	2
A	without()	0	6	1
A	replace()	0	14	3
A	merge()	0	8	2
A	exists()	0	12	3
A	contains()	0	8	2
A	__toString()	0	4	1
A	render()	0	18	2
A	getStorage()	0	4	1
A	getIterator()	0	4	1
A	count()	0	4	1
A	toArray()	0	15	3
A	getValuesAsArray()	0	9	1
A	serialize()	0	6	1
A	unserialize()	0	13	1

<?php

namespace drupol\htmltag\Attributes;

use drupol\htmltag\AbstractBaseHtmlTagObject;
use drupol\htmltag\Attribute\AttributeFactoryInterface;
use drupol\htmltag\Attribute\AttributeInterface;

/**
 * Class Attributes.
 */
class Attributes extends AbstractBaseHtmlTagObject implements AttributesInterface
{
    /**
     * Stores the attribute data.
     *
     * @var \drupol\htmltag\Attribute\AttributeInterface[]
     */
    private $storage = [];

    /**
     * The attribute factory.
     *
     * @var \drupol\htmltag\Attribute\AttributeFactoryInterface
     */
    private $attributeFactory;

    /**
     * Attributes constructor.
     *
     * @param \drupol\htmltag\Attribute\AttributeFactoryInterface $attributeFactory
     *   The attribute factory.
     * @param mixed[] $attributes
     *   The input attributes.
     */
    public function __construct(AttributeFactoryInterface $attributeFactory, $attributes = [])
    {
        $this->attributeFactory = $attributeFactory;
        $this->import($attributes);
    }

    /**
     * {@inheritdoc}
     */
    public function import($attributes)
    {
        foreach ($attributes as $name => $value) {
            $this->set($name, $value);
        }

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function set($name, ...$value)
    {
        $this->storage[$name] = $this->attributeFactory->getInstance($name, $value);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function offsetGet($name)
    {
        if (!isset($this->storage[$name])) {
            $this->set($name);
        }

        return $this->storage[$name];
    }

    /**
     * {@inheritdoc}
     */
    public function offsetSet($name, $value = null)
    {
        $this->set($name, $value);
    }

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

    /**
     * {@inheritdoc}
     */
    public function offsetExists($name)
    {
        return isset($this->storage[$name]);
    }

    /**
     * {@inheritdoc}
     */
    public function append($key, ...$value)
    {
        $this->storage += array(
            $key => $this->attributeFactory->getInstance($key),
        );

        $this->storage[$key]->append($value);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function remove($key, ...$value)
    {
        if (isset($this->storage[$key])) {
            $this->storage[$key]->remove($value);
        }

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function delete(...$name)
    {
        foreach ($this->normalizeValue($name) as $attribute_name) {
            unset($this->storage[$attribute_name]);
        }

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function without(...$key)
    {
        $attributes = clone $this;

        return $attributes->delete($key);
    }

    /**
     * {@inheritdoc}
     */
    public function replace($key, $value, ...$replacement)
    {
        if (!isset($this->storage[$key])) {
            return $this;
        }

        if (!$this->contains($key, $value)) {
            return $this;
        }

        $this->storage[$key]->replace($value, $replacement);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function merge(array $data = [])
    {
        foreach ($data as $key => $value) {
            $this->append($key, $value);
        }

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function exists($key, $value = null)
    {
        if (!isset($this->storage[$key])) {
            return false;
        }

        if (null !== $value) {
            return $this->contains($key, $value);
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function contains($key, ...$value)
    {
        if (!isset($this->storage[$key])) {
            return false;
        }

        return $this->storage[$key]->contains($value);
    }

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

    /**
     * {@inheritdoc}
     */
    public function render()
    {
        $attributes = \implode(
            ' ',
            $this->ensureArray(
                \array_reduce(
                    $this->toArray(),
                    function ($carry, $key) {
                        $carry[] = $key->render();

                        return $carry;
                    }
                )
            )
        );

        return $attributes ? ' ' . $attributes : '';
    }

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

    /**
     * {@inheritdoc}
     */
    public function getIterator()
    {
        return new \ArrayIterator($this->toArray());
    }

    /**
     * {@inheritdoc}
     */
    public function count()
    {
        return \count($this->toArray());
    }

    /**
     * {@inheritdoc}
     */
    public function toArray()
    {
        // If empty, just return an empty array.
        if ([] === $this->storage) {
            return [];
        }

        $result = [];

        foreach ($this->preprocess($this->storage) as $attribute) {
            $result[$attribute->getName()] = $attribute;
        }

        return $result;
    }

    /**
     * {@inheritdoc}
     */
    public function getValuesAsArray()
    {
        return \array_map(
            function (AttributeInterface $attribute) {
                return $attribute->getValuesAsArray();
            },
            $this->toArray()
        );
    }

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

    /**
     * {@inheritdoc}
     */
    public function unserialize($serialized)
    {
        $unserialize = unserialize($serialized);
        $attributeFactory = $this->attributeFactory;

        $this->storage = array_map(
            function ($name, $values) use ($attributeFactory) {
                return $attributeFactory::build($name, $values);
            },
            array_keys($unserialize['storage']),
            array_values($unserialize['storage'])
        );
    }
}