drupol\htmltag\AbstractBaseHtmlTagObject

Complexity

Total Complexity

13

Size/Duplication

Total Lines	129
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	normalizeValue()	0	20	2
A	ensureFlatArray()	0	19	2
B	ensureString()	0	26	8
A	preprocess()	0	4	1
	escape()	0	1	?

<?php

namespace drupol\htmltag;

/**
 * Class AbstractBaseHtmlTagObject
 */
abstract class AbstractBaseHtmlTagObject
{
    /**
     * Normalize the values.
     *
     * @param mixed $values
     *  The value to normalize.
     *
     * @return array
     *   The value normalized.
     */
    public function normalizeValue($values)
    {
        var_dump('BEFORE');

var_dump('BEFORE'); looks like debug code. Are you sure you do not want to remove it? This might expose sensitive data.

        var_dump($values);

        $ttt = array_filter(
            array_map(
                function ($item) {
                    return is_object($item) ?
                        $this->ensureString($item):
                        $this->escape($this->ensureString($item));
                },
                $this->ensureFlatArray((array) $values))
        , '\is_string');

Space found before comma in function call

        var_dump('AFTER');

var_dump('AFTER'); looks like debug code. Are you sure you do not want to remove it? This might expose sensitive data.

        var_dump($ttt);

        return $ttt;
    }

    /**
     * Transform a multidimensional array into a flat array.
     *
     * We could use a iterator_to_array() with a custom RecursiveArrayIterator.
     * But it seems to be even slower.
     *
     * @see http://php.net/manual/en/class.recursivearrayiterator.php#106519
     *
     * @param mixed[] $array
     *   The input array.
     *
     * @return mixed[]
     *   The array with only one dimension.
     */
    public function ensureFlatArray(array $array)
    {
        return \array_reduce(
            $array,
            function ($carry, $item) {
                if (\is_array($item)) {
                    return \array_merge(
                        $carry,
                        $this->ensureFlatArray($item)
                    );
                }

                $carry[] = $item;

                return $carry;
            },
            []
        );
    }

    /**
     * Make sure the value is an array.
     *
     * @param mixed $data
     *   The input value.
     *
     * @return string|NULL
     *   The input value in an array.
     */
    public function ensureString($data)
    {
        $return = null;

        switch (\gettype($data)) {
            case 'string':
                $return = $data;
                break;
            case 'integer':
            case 'double':
                $return = (string) $data;
                break;
            case 'object':
                if (\method_exists($data, '__toString')) {
                    $return = $data->__toString();
                }
                break;
            case 'boolean':
            case 'array':
            default:
                $return = NULL;

TRUE, FALSE and NULL must be lowercase; expected null, but found NULL.

                break;
        }

        return $return;
    }

    /**
     * Preprocess values before they are returned to user.
     *
     * @param array $values
     *   The raw values.
     * @param string $name
     *   The name of the object.
     *
     * @return array|\drupol\htmltag\Attribute\AttributeInterface[]
     *   The values.
     */
    public function preprocess(array $values, $name = null)

The parameter $name is not used and could be removed.

    {
        return $values;
    }

    /**
     * Sanitize a value.
     *
     * @param string|null $value
     *   The value to sanitize
     *
     * @return string
     *   The value sanitized.
     */
    abstract protected function escape($value);
}