AustinHeap\Database\Encryption\EncryptionHelper

Complexity

Total Complexity

49

Size/Duplication

Total Lines	353
Duplicated Lines	0 %

Test Coverage

Coverage

99.11%

Importance

Changes	1
Bugs	0	Features	0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	getControlCharacters()	0	13	3
A	getVersion()	0	6	1
A	setEnabled()	0	5	1
A	setPrefix()	0	10	4
A	isDisabled()	0	3	1
A	isVersionless()	0	3	1
A	getPrefix()	0	12	5
A	isEnabled()	0	8	4
A	setVersionless()	0	3	2
A	setVersioning()	0	6	1
A	isVersioning()	0	8	4
A	buildHeader()	0	21	3
A	getInstance()	0	3	1
A	getHeaderPrefix()	0	12	2
A	setDisabled()	0	3	2
A	reset()	0	10	1
A	setHeaderPrefix()	0	8	2
A	__construct()	0	3	1
B	getVersionParts()	0	26	9
A	getVersionForPrefix()	0	3	1

<?php
/**
 * src/EncryptionHelper.php.
 *
 * @author      Austin Heap <me@austinheap.com>
 * @version     v0.2.1
 */
declare(strict_types=1);

namespace AustinHeap\Database\Encryption;

use Illuminate\Support\Facades\Config;
use RuntimeException;

/**
 * EncryptionHelper.
 *
 * @link        https://github.com/austinheap/laravel-database-encryption
 * @link        https://packagist.org/packages/austinheap/laravel-database-encryption
 * @link        https://austinheap.github.io/laravel-database-encryption/classes/AustinHeap.Database.Encryption.EncryptionHelper.html
 */
class EncryptionHelper extends EncryptionDefaults
{
    /**
     * Internal version number.
     *
     * @var string
     */
    public const VERSION = '0.1.2';

    /**
     * Private enable flag cache.
     *
     * @var null|bool
     */
    private $enabledCache = null;

    /**
     * Private versioning flag cache.
     *
     * @var null|bool
     */
    private $versioningCache = null;

    /**
     * Private version parts cache.
     *
     * @var null|array
     */
    private $versionPartsCache = null;

    /**
     * Private control characters cache.
     *
     * @var null|array
     */
    private $controlCharactersCache = null;

    /**
     * Private prefix cache.
     *
     * @var null|string
     */
    private $prefixCache = null;

    /**
     * Private header prefix cache.
     *
     * @var null|string
     */
    private $headerPrefixCache = null;

    /**
     * EncryptionHelper constructor.
     */
    public function __construct()
    {
        $this->reset();
    }

    /**
     * Reset the class; mostly the cache.
     *
     * @return EncryptionHelper
     */
    public function reset(): self
    {
        $this->enabledCache =
        $this->versioningCache =
        $this->versionPartsCache =
        $this->controlCharactersCache =
        $this->prefixCache =
        $this->headerPrefixCache = null;

        return $this;
    }

    /**
     * Get the package version.
     *
     * @return string
     */
    public function getVersion(): string
    {
        throw_if(! defined('LARAVEL_DATABASE_ENCRYPTION_VERSION'), RuntimeException::class,
                 'The provider did not boot.');

        return LARAVEL_DATABASE_ENCRYPTION_VERSION;
    }

    /**
     * Set the enabled flag.
     *
     * @return bool
     */
    public function setEnabled(?bool $value = null): self
    {
        $this->enabledCache = $value;

        return $this;

The expression return $this returns the type AustinHeap\Database\Encryption\EncryptionHelper which is incompatible with the documented return type boolean.

    }

    /**
     * Check the enabled flag.
     *
     * @return bool
     */
    public function isEnabled(): bool
    {
        if (is_null($this->enabledCache)) {
            $enabled = Config('database-encryption.enabled', null);
            $this->enabledCache = ! is_null($enabled) && is_bool($enabled) ? $enabled : self::isEnabledDefault();
        }

        return $this->enabledCache;
    }

    /**
     * Set the enabled flag inverse.
     *
     * @return bool
     */
    public function setDisabled(?bool $value = null): self
    {
        return $this->setEnabled(is_bool($value) ? ! $value : null);

The expression return $this->setEnabled(is_bool($value) ? ! $value : null) returns the type AustinHeap\Database\Encryption\EncryptionHelper which is incompatible with the documented return type boolean.

    }

    /**
     * Check the enabled flag inverse.
     *
     * @return bool
     */
    public function isDisabled(): bool
    {
        return ! $this->isEnabled();
    }

    /**
     * Set the versioning flag.
     *
     * @return null|bool
     */
    public function setVersioning(?bool $value = null): self
    {
        $this->reset();
        $this->versioningCache = $value;

        return $this;

The expression return $this returns the type AustinHeap\Database\Encryption\EncryptionHelper which is incompatible with the documented return type boolean|null.

    }

    /**
     * Check the versioning flag.
     *
     * @return bool
     */
    public function isVersioning(): bool
    {
        if (is_null($this->versioningCache)) {
            $versioning = Config('database-encryption.versioning', null);
            $this->versioningCache = ! is_null($versioning) && is_bool($versioning) ? $versioning : self::isVersioningDefault();
        }

        return $this->versioningCache;
    }

    /**
     * Set the enabled flag inverse.
     *
     * @return null|bool
     */
    public function setVersionless(?bool $value = null): self
    {
        return $this->setVersioning(is_bool($value) ? ! $value : null);

The expression return $this->setVersioning(is_bool($value) ? ! $value : null) returns the type AustinHeap\Database\Encryption\EncryptionHelper which is incompatible with the documented return type boolean|null.

    }

    /**
     * Check the versioning flag inverse.
     *
     * @return bool
     */
    public function isVersionless(): bool
    {
        return ! $this->isVersioning();
    }

    /**
     * Get the package version in parts.
     *
     * @return array
     */
    public function getVersionParts(?int $padding = null): array
    {
        if (! is_array($this->versionPartsCache)) {
            $this->versionPartsCache = [];
        }

        $padding = is_int($padding) && $padding === 0 ? null : $padding;
        $key = 'padding-'.(is_null($padding) ? 'null' : (string) $padding);

        if (! array_key_exists($key, $this->versionPartsCache)) {
            $parts = explode('.', $this->getVersion());

            $this->versionPartsCache[$key] = array_map(function ($part) use ($padding) {
                $part = (string) $part;

                if (is_null($padding)) {
                    return $part;
                }

                $length = strlen(is_string($part) ? $part : (string) $part);

The condition is_string($part) is always true.

                return $length == $padding ? $part : str_repeat('0', $padding - $length).$part;
            }, $parts);
        }

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

    /**
     * Get the package version for a prefix.
     *
     * @return string
     */
    public function getVersionForPrefix(int $padding = 2, string $glue = '-'): string
    {
        return 'VERSION-'.implode($glue, $this->getVersionParts($padding));
    }

    /**
     * Set the configured header prefix.
     *
     * @return EncryptionHelper
     */
    public function setHeaderPrefix(?string $value = null): self
    {
        throw_if(is_string($value) && strlen(trim($value)) == 0, RuntimeException::class,
                 'Cannot use empty string as header prefix.');

        $this->headerPrefixCache = $value;

        return $this;
    }

    /**
     * Get the configured header prefix.
     *
     * @return string
     */
    public function getHeaderPrefix(): string
    {
        if (is_null($this->headerPrefixCache)) {
            $characters = $this->getControlCharacters();

            $this->headerPrefixCache = $characters['header']['start']['string'].
                                       $characters['prefix']['start']['string'].
                                       $this->getPrefix().
                                       $characters['prefix']['stop']['string'];
        }

        return $this->headerPrefixCache;
    }

    /**
     * Build a header string, optionally with an object.
     *
     * @return string
     */
    public function buildHeader($object = null): string
    {
        $characters = $this->getControlCharacters();

        return $characters['header']['start']['string'].
               $characters['prefix']['start']['string'].
               $this->getPrefix().
               $characters['prefix']['stop']['string'].
               $characters['field']['start']['string'].
               'version'.
               $characters['field']['delimiter']['string'].
               self::getVersionForPrefix().

The method AustinHeap\Database\Encryption\EncryptionHelper::getVersionForPrefix() is not static, but was called statically.

               $characters['field']['stop']['string'].
               (is_null($object) ? '' :
                   $characters['field']['start']['string'].
                   'type'.
                   $characters['field']['delimiter']['string'].
                   gettype($object).'['.(is_object($object) ? get_class($object) : 'native').']'.
                   $characters['field']['stop']['string']
               ).
               $characters['header']['stop']['string'];
    }

    /**
     * Set the configured prefix.
     *
     * @return EncryptionHelper
     */
    public function setPrefix(?string $value = null): self
    {
        throw_if(is_string($value) && strlen(trim($value)) == 0, RuntimeException::class,
                 'Cannot use empty string as prefix.');

        $this->prefixCache = is_string($value) && $this->isVersioning() ?
            str_replace('%VERSION%', $this->getVersionForPrefix(), $value) :
            $value;

        return $this;
    }

    /**
     * Get the configured prefix.
     *
     * @return string
     */
    public function getPrefix(): string
    {
        if (is_null($this->prefixCache)) {
            $prefix = Config::get('database-encryption.prefix', null);
            $prefix = ! empty($prefix) && is_string($prefix) ? $prefix : self::getPrefixDefault();

            $this->prefixCache = $this->isVersioning() ?
                str_replace('%VERSION%', $this->getVersionForPrefix(), $prefix) :
                $prefix;
        }

        return $this->prefixCache;
    }

    /**
     * Get the configured control characters.
     *
     * @return array
     */
    public function getControlCharacters(?string $type = null): array
    {
        $defaults = self::getControlCharactersDefault();

The assignment to $defaults is dead and can be removed.

        $characters = self::getControlCharactersDefault();

        if (! is_null($type)) {
            throw_if(! array_key_exists($type, $characters),
                     'Control characters do not exist for $type: "'.(empty($type) ? '(empty)' : $type).'".');

            return $characters[$type];
        }

        return $characters;
    }

    /**
     * Get the singleton of this class.
     *
     * @return EncryptionHelper
     */
    public static function getInstance(): self
    {
        return EncryptionFacade::getInstance();
    }
}