PSR7Sessions\Storageless\Session\DefaultSessionData

Complexity

Total Complexity

16

Size/Duplication

Total Lines	146
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

100%

Importance

Changes

0

<?php
use const JSON_PRESERVE_ZERO_FRACTION;

final class DefaultSessionData implements SessionInterface
{
    /** @var array<string, int|bool|string|float|mixed[]|null> */
    private array $data;

This code did not parse for me. Apparently, there is an error somewhere around this line:

Syntax error, unexpected T_ARRAY, expecting T_FUNCTION or T_CONST

    /** @var array<string, int|bool|string|float|mixed[]|null> */
    private array $originalData;

    /**
     * Instantiation via __construct is not allowed, use
     * - {@see DefaultSessionData::fromDecodedTokenData}
     * - {@see DefaultSessionData::fromTokenData}
     * - {@see DefaultSessionData::newEmptySession}
     * instead
     */
    private function __construct()
    {
    }

    public static function fromDecodedTokenData(stdClass $data) : self
    {
        $instance = new self();

        $arrayShapedData = self::convertValueToScalar($data);
        assert(is_array($arrayShapedData));

        $instance->originalData = $instance->data = $arrayShapedData;

        return $instance;
    }

    /** @param mixed[] $data */
    public static function fromTokenData(array $data) : self
    {
        $instance = new self();

        $instance->data = [];

        foreach ($data as $key => $value) {
            $instance->set((string) $key, $value);
        }

        $instance->originalData = $instance->data;

        return $instance;
    }

    public static function newEmptySession() : self
    {
        $instance = new self();

        $instance->originalData = $instance->data = [];

        return $instance;
    }

    /**
     * {@inheritDoc}
     */
    public function set(string $key, $value) : void
    {
        $this->data[$key] = self::convertValueToScalar($value);
    }

    /**
     * {@inheritDoc}
     */
    public function get(string $key, $default = null)
    {
        if (! $this->has($key)) {
            return self::convertValueToScalar($default);
        }

        return $this->data[$key];
    }

    public function remove(string $key) : void
    {
        unset($this->data[$key]);
    }

    public function clear() : void
    {
        $this->data = [];
    }

    public function has(string $key) : bool
    {
        return array_key_exists($key, $this->data);
    }

    public function hasChanged() : bool
    {
        return $this->data !== $this->originalData;
    }

    public function isEmpty() : bool
    {
        return ! count($this->data);
    }

    public function jsonSerialize() : object
    {
        return (object) $this->data;
    }

    /**
     * @param int|bool|string|float|mixed[]|object|JsonSerializable|null $value
     *
     * @return int|bool|string|float|mixed[]
     */
    private static function convertValueToScalar($value)
    {
        $jsonScalar = json_encode($value, JSON_PRESERVE_ZERO_FRACTION);

        if (! is_string($jsonScalar)) {
            // @TODO use PHP 7.3 and JSON_THROW_ON_ERROR instead? https://wiki.php.net/rfc/json_throw_on_error
            throw new InvalidArgumentException(sprintf(
                'Could not serialise given value %s due to %s (%s)',
                var_export($value, true),
                json_last_error_msg(),
                json_last_error()
            ));
        }

        return json_decode($jsonScalar, true);
    }
}