lav45\settings\Settings

Complexity

Total Complexity

27

Size/Duplication

Total Lines	256
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	4
Bugs	0	Features	0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	set()	0	11	1
A	get()	0	14	3
A	afterSetValue()	0	6	1
A	offsetUnset()	0	3	1
A	afterGetValue()	0	7	1
A	afterDeleteValue()	0	5	1
A	offsetExists()	0	3	1
A	buildKey()	0	10	4
A	offsetSet()	0	3	1
A	beforeGetValue()	0	6	1
A	decode()	0	9	3
A	offsetGet()	0	4	1
A	encode()	0	9	3
A	delete()	0	10	1
A	beforeDeleteValue()	0	5	1
A	beforeSetValue()	0	7	1
A	init()	0	4	1
A	afterDecodeValue()	0	8	1

<?php
/**
 * @link https://github.com/lav45/yii2-settings
 * @copyright Copyright (c) 2016 LAV45
 * @author Alexey Loban <lav451@gmail.com>
 * @license http://opensource.org/licenses/BSD-3-Clause
 */

namespace lav45\settings;

use lav45\settings\behaviors\CacheBehavior;
use lav45\settings\behaviors\QuickAccessBehavior;
use lav45\settings\events\DecodeEvent;
use lav45\settings\events\DeleteEvent;
use lav45\settings\events\GetEvent;
use lav45\settings\events\SetEvent;
use lav45\settings\storage\DbStorage;
use lav45\settings\storage\StorageInterface;
use yii\base\Component;
use yii\di\Instance;
use yii\helpers\StringHelper;

/**
 * Class Settings
 * @package lav45\settings
 * @mixin CacheBehavior
 * @mixin QuickAccessBehavior
 */
class Settings extends Component implements \ArrayAccess
{
    public const EVENT_BEFORE_GET = 'beforeGetValue';
    public const EVENT_AFTER_GET = 'afterGetValue';
    public const EVENT_AFTER_DECODE_VALUE = 'afterDecodeValue';
    public const EVENT_BEFORE_SET = 'beforeSetValue';
    public const EVENT_AFTER_SET = 'afterSetValue';
    public const EVENT_BEFORE_DELETE = 'beforeDeleteValue';
    public const EVENT_AFTER_DELETE = 'afterDeleteValue';

    /**
     * @var string
     */
    public $keyPrefix;
    /**
     * @var bool
     */
    public $buildKey = true;
    /**
     * @var array|boolean
     */
    public $serializer;
    /**
     * @var StorageInterface|string|array
     */
    public $storage = DbStorage::class;

    /**
     * @inheritdoc
     */
    public function init()
    {
        parent::init();
        $this->storage = Instance::ensure($this->storage, StorageInterface::class);
    }

    /**
     * @param string|array $key
     * @return string
     */
    public function buildKey($key)
    {
        if ($this->buildKey === true) {
            if (is_string($key)) {
                $key = StringHelper::byteLength($key) <= 32 ? $key : md5($key);
            } else {
                $key = md5(json_encode($key, JSON_THROW_ON_ERROR));
            }
        }
        return $this->keyPrefix . $key;

Are you sure $key of type array|string can be used in concatenation?

    }

    /**
     * @param mixed $value
     * @return string
     */
    public function encode($value)
    {
        if ($this->serializer === null) {
            return serialize($value);
        }
        if ($this->serializer !== false) {
            return call_user_func($this->serializer[0], $value);
        }
        return $value;
    }

    /**
     * @param string $value
     * @return mixed
     */
    public function decode($value)
    {
        if ($this->serializer === null) {
            return @unserialize($value, ['allowed_classes' => true]);
        }
        if ($this->serializer !== false) {
            return call_user_func($this->serializer[1], $value);
        }
        return $value;
    }

    /**
     * @param string|array $key
     * @param null $default

Are you sure the doc-type for parameter $default is correct as it would always require null to be passed?

     * @return mixed
     */
    public function get($key, $default = null)
    {
        $key = $this->buildKey($key);
        $value = $this->beforeGetValue($key);
        if ($value === null) {

The condition $value === null is always false.

            $value = $this->storage->getValue($key);
            $value = $this->afterGetValue($key, $value);
        }
        if ($value === false) {

The condition $value === false is always false.

            return $default;
        }

        $value = $this->decode($value);
        return $this->afterDecodeValue($key, $value, $default);
    }

    /**
     * @param string|array $key
     * @param mixed $value
     * @return boolean
     */
    public function set($key, $value)
    {
        $value = $this->beforeSetValue($key, $value);

        $key = $this->buildKey($key);
        $value = $this->encode($value);
        $result = $this->storage->setValue($key, $value);

        $this->afterSetValue($key, $value);

        return $result;
    }

    /**
     * @param string $key
     * @return boolean
     */
    public function delete($key)
    {
        $this->beforeDeleteValue($key);

        $key = $this->buildKey($key);
        $result = $this->storage->deleteValue($key);

        $this->afterDeleteValue($key);

        return $result;
    }

    /**
     * @param string $key
     * @return string
     */
    protected function beforeGetValue(&$key)
    {
        $event = new GetEvent();
        $event->key = &$key;
        $this->trigger(self::EVENT_BEFORE_GET, $event);
        return $event->value;
    }

    /**
     * @param string $key
     * @param string $value
     * @return string
     */
    protected function afterGetValue($key, $value)
    {
        $event = new GetEvent();
        $event->key = $key;
        $event->value = $value;
        $this->trigger(self::EVENT_AFTER_GET, $event);
        return $event->value;
    }

    /**
     * @param string|array $key
     * @param mixed $value
     * @param mixed $default
     * @return mixed
     */
    protected function afterDecodeValue($key, $value, $default)
    {
        $event = new DecodeEvent();
        $event->key = $key;
        $event->value = $value;
        $event->default = $default;
        $this->trigger(self::EVENT_AFTER_DECODE_VALUE, $event);
        return $event->value;
    }

    /**
     * @param string|array $key
     * @param mixed $value
     * @return mixed
     */
    protected function beforeSetValue($key, $value)
    {
        $event = new SetEvent();
        $event->key = $key;
        $event->value = $value;
        $this->trigger(self::EVENT_BEFORE_SET, $event);
        return $event->value;
    }

    /**
     * @param string $key
     * @param string $value
     */
    protected function afterSetValue($key, $value)
    {
        $event = new SetEvent();
        $event->key = $key;
        $event->value = $value;
        $this->trigger(self::EVENT_AFTER_SET, $event);
    }

    /**
     * @param string $key
     */
    protected function beforeDeleteValue($key)
    {
        $event = new DeleteEvent();
        $event->key = $key;
        $this->trigger(self::EVENT_BEFORE_DELETE, $event);
    }

    /**
     * @param string $key
     */
    protected function afterDeleteValue($key)
    {
        $event = new DeleteEvent();
        $event->key = $key;
        $this->trigger(self::EVENT_AFTER_DELETE, $event);
    }

    /**
     * @inheritDoc
     */
    public function offsetExists($offset): bool
    {
        return $this->get($offset) !== null;
    }

    /**
     * @inheritDoc
     */
    #[\ReturnTypeWillChange]
    public function offsetGet($offset)
    {
        return $this->get($offset);
    }

    /**
     * @inheritDoc
     */
    public function offsetSet($offset, $value): void
    {
        $this->set($offset, $value);
    }

    /**
     * @inheritDoc
     */
    public function offsetUnset($offset): void
    {
        $this->delete($offset);
    }
}