Wszetko\Sitemap\Items\DataTypes\StringType

Complexity

Total Complexity

46

Size/Duplication

Total Lines	272
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	1	Features	0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	setAllowedValues()	0	13	4
A	getMaxLength()	0	3	1
A	setMinLength()	0	5	1
A	getMinLength()	0	3	1
A	setValueRegex()	0	6	1
A	getAllowedValues()	0	3	1
A	setMaxLength()	0	5	1
A	setConversion()	0	9	3
A	getConversion()	0	3	1
A	checkValueRegex()	0	10	5
A	checkValue()	0	7	1
A	getValueRegex()	0	7	5
A	convertValue()	0	10	5
A	setValue()	0	18	5
B	checkValueLength()	0	9	7
A	checkIfValueIsInAllowedValues()	0	12	4

<?php

declare(strict_types=1);

/**
 * This file is part of Wszetko Sitemap.
 *
 * (c) Paweł Kłopotek-Główczewski <pawelkg@pawelkg.com>
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

namespace Wszetko\Sitemap\Items\DataTypes;

use InvalidArgumentException;
use Wszetko\Sitemap\Interfaces\DataType;

/**
 * Class StringType.
 *
 * @package Wszetko\Sitemap\Items\DataTypes
 */
class StringType extends AbstractDataType
{
    /**
     * @var int
     */
    protected $minLength;

    /**
     * @var int
     */
    protected $maxLength;

    /**
     * @var null|array
     */
    protected $allowedValues;

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

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

    /**
     * @var null|string
     */
    protected $conversion;

    /**
     * @return null|int
     */
    public function getMinLength(): ?int
    {
        return $this->minLength;
    }

    /**
     * @param int $minLength
     *
     * @return \Wszetko\Sitemap\Items\DataTypes\StringType
     */
    public function setMinLength(int $minLength): self
    {
        $this->minLength = $minLength;

        return $this;
    }

    /**
     * @return null|int
     */
    public function getMaxLength(): ?int
    {
        return $this->maxLength;
    }

    /**
     * @param int $maxLength
     *
     * @return self
     */
    public function setMaxLength(int $maxLength): self
    {
        $this->maxLength = $maxLength;

        return $this;
    }

    /**
     * @return null|array
     */
    public function getAllowedValues(): ?array
    {
        return $this->allowedValues;
    }

    /**
     * @param null|array|string $allowedValues
     *
     * @return \Wszetko\Sitemap\Items\DataTypes\StringType
     */
    public function setAllowedValues($allowedValues): self
    {
        if (is_string($allowedValues)) {
            $allowedValues = explode(',', $allowedValues);

            foreach ($allowedValues as $allowedValue) {
                $this->allowedValues[] = trim($allowedValue);
            }
        } elseif (is_array($allowedValues)) {
            $this->allowedValues = $allowedValues;
        }

        return $this;
    }

    /**
     * @param string $regex
     * @param string $regexGroup
     *
     * @return \Wszetko\Sitemap\Items\DataTypes\StringType
     */
    public function setValueRegex(string $regex, string $regexGroup): self
    {
        $this->regex = $regex;
        $this->regexGroup = $regexGroup;

        return $this;
    }

    /**
     * @return null|array
     */
    public function getValueRegex(): ?array
    {
        if (null !== $this->regex && '' !== $this->regex && null !== $this->regexGroup && '' !== $this->regexGroup) {
            return [$this->regexGroup => $this->regex];
        }

        return null;
    }

    /**
     * @param string $conversion
     *
     * @return $this
     */
    public function setConversion(string $conversion): self
    {
        if (in_array($conversion, ['upper', 'UPPER', 'Upper'], true)) {
            $this->conversion = 'upper';
        } elseif (in_array($conversion, ['lower', 'LOWER', 'Lower'], true)) {
            $this->conversion = 'lower';
        }

        return $this;
    }

    /**
     * @return null|string
     */
    public function getConversion(): ?string
    {
        return $this->conversion;
    }

    /**
     * @param mixed $value
     * @param array $parameters
     *
     * @return static
     *
     * @throws \InvalidArgumentException
     */
    public function setValue($value, $parameters = []): DataType
    {
        if (null !== $value) {
            $value = (string) $value;
            $this->checkValue($value);
        }

        if (
            (null === $value
            || '' === $value)
            && $this->isRequired()
        ) {
            throw new InvalidArgumentException($this->getName() . ' need to be set.');
        }

        parent::setValue($value, $parameters);

        return $this;
    }

    /**
     * @param string $value
     * @param-out null|string $value
     *
     * @return void
     */
    private function checkValue(string &$value):void
    {
        $value = trim($value);
        $this->checkValueLength($value);
        $this->convertValue($value);
        $this->checkIfValueIsInAllowedValues($value);
        $this->checkValueRegex($value);
    }

    /**
     * @param null|string $value
     * @param-out null|string $value
     *
     * @return void
     */
    private function checkValueLength(?string &$value):void
    {
        if (null !== $value) {
            if (null !== $this->getMinLength() && mb_strlen($value) < $this->getMinLength()) {
                $value = null;
            }

            if (null !== $this->getMaxLength() && null !== $value && mb_strlen($value) > $this->getMaxLength()) {
                $value = mb_substr($value, 0, $this->getMaxLength());
            }
        }
    }

    /**
     * @param null|string $value
     * @param-out null|string $value
     *
     * @return void
     */
    private function convertValue(?string &$value): void
    {
        if (null !== $value) {
            $conversion = $this->getConversion();

            if (is_string($conversion)) {
                if ('upper' == $conversion) {
                    $value = mb_strtoupper($value);
                } elseif ('lower' == $conversion) {
                    $value = mb_strtolower($value);
                }
            }
        }
    }

    /**
     * @param null|string $value
     * @param-out null|string $value
     *
     * @return void
     */
    private function checkIfValueIsInAllowedValues(?string &$value): void
    {
        if (null !== $value) {
            $allowedValues = $this->getAllowedValues();

            if (null !== $allowedValues) {
                $match = preg_grep("/{$value}/i", $allowedValues);

                if ([] === $match) {
                    $value = null;
                } else {
                    $value = array_values($match)[0];
                }
            }
        }
    }

    /**
     * @param null|string $value
     * @param-out null|string $value
     *
     * @return void
     */
    private function checkValueRegex(?string &$value): void
    {
        if (null !== $value) {
            $regex = $this->getValueRegex();

            if (null !== $regex && [] !== $regex) {
                $match = preg_match(array_values($regex)[0], $value);

                if (1 !== $match) {
                    $value = null;
                }
            }
        }
    }
}