Kartavik\Yii2\Behaviors\EnumMappingBehavior

Complexity

Total Complexity

17

Size/Duplication

Total Lines	133
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	events()	0	12	1
A	toValues()	0	15	4
A	toEnums()	0	15	5
A	castTypeIfExist()	0	6	2
A	validateAttributes()	0	8	4
A	isUseKey()	0	4	1

<?php

/**
 * @author Roman Varkuta <roman.varkuta@gmail.com>
 * @license MIT
 * @see https://github.com/myclabs/php-enum
 * @version 2.0
 */

declare(strict_types=1);

namespace Kartavik\Yii2\Behaviors;

use MyCLabs\Enum\Enum;
use yii\base;
use yii\db;

/**
 * Class EnumMappingBehavior
 *
 * ```php
 * return [
 *      'enum' => [
 *          'class' => \Kartavik\Yii2\Behaviors\EnumMappingBehavior::class,
 *          'map' => [
 *              'attribute1' => FirstYourEnum::class,
 *              'attribute2' => SecondYourEnum::class,
 *          ],
 *          'attributesType' => [
 *              'attribute1' => 'integer',
 *              'attribute2' => 'float',
 *          ],
 *      ],
 * ];
 * ```
 *
 * @package Kartavik\Yii2\Behaviors
 * @since 1.0
 */
class EnumMappingBehavior extends base\Behavior
{
    public const EVENT_TO_ENUMS = 'toEnums';
    public const EVENT_TO_VALUES = 'toValues';

    /**
     * Key used for EnumMappingBehavior class, value is array of attributes that must be converted into this enum
     *
     * ```php
     * [
     *      'attribute1' => FirstYourEnum::class,
     *      'attribute2' => SecondYourEnum::class,
     * ]
     * ```
     *
     * @var array
     * @since 2.0
     */
    public $map;

    /**
     * In some cases database enum type can work only with string, so this parameter help behaviour to cast variable to
     * needs type
     *
     * ```php
     * [
     *      'attribute1' => 'integer',
     *      'attribute2' => 'float',
     * ]
     * ```
     *
     * @var array
     * @since 1.1
     */
    public $attributesType = [];

    /**
     * If you want use keys for mapping just add related attribute to this property
     *
     * ```php
     * [
     *      'attribute1', // values for this attribute will be as key in enum
     * ]
     * ```
     *
     * @var array
     * @since 2.2
     */
    public $useKeyFor = [];

    /**
     * {@inheritdoc}
     */
    public function events(): array
    {
        return [
            EnumMappingBehavior::EVENT_TO_ENUMS => 'toEnums',
            EnumMappingBehavior::EVENT_TO_VALUES => 'toValues',
            db\ActiveRecord::EVENT_AFTER_FIND => EnumMappingBehavior::EVENT_TO_ENUMS,
            db\ActiveRecord::EVENT_AFTER_INSERT => EnumMappingBehavior::EVENT_TO_ENUMS,
            db\ActiveRecord::EVENT_AFTER_UPDATE => EnumMappingBehavior::EVENT_TO_ENUMS,
            db\ActiveRecord::EVENT_BEFORE_INSERT => EnumMappingBehavior::EVENT_TO_VALUES,
            db\ActiveRecord::EVENT_BEFORE_UPDATE => EnumMappingBehavior::EVENT_TO_VALUES,
        ];
    }

    /**
     * @throws base\InvalidConfigException
     */
    public function toValues(): void
    {
        $this->validateAttributes();

        foreach ($this->map as $attribute => $enum) {
            $value = $this->owner->{$attribute};

            if ($value instanceof $enum) {
                /** @var Enum $value */
                $enumValue = $this->isUseKey($attribute) ? $value->getKey() : $value->getValue();
                $this->castTypeIfExist($enumValue, $attribute);
                $this->owner->{$attribute} = $enumValue;
            }
        }
    }

    /**
     * @throws base\InvalidConfigException
     * @throws \UnexpectedValueException
     */
    public function toEnums(): void
    {
        $this->validateAttributes();

        foreach ($this->map as $attribute => $enum) {
            $value = $this->owner->{$attribute};

            if (!$value instanceof Enum) {
                $this->castTypeIfExist($value, $attribute);
                $this->owner->{$attribute} = isset($this->owner->{$attribute}) && $this->isUseKey($attribute)
                    ? \call_user_func([$enum, $value])
                    : new $enum($value);
            }
        }
    }

    /**
     * @param mixed  $variable
     * @param string $attribute
     */
    protected function castTypeIfExist(&$variable, string $attribute): void
    {
        if (isset($this->attributesType[$attribute])) {
            \settype($variable, $this->attributesType[$attribute]);
        }
    }

    /**
     * @throws base\InvalidConfigException
     */
    protected function validateAttributes(): void
    {
        foreach ($this->map as $attribute => $enum) {
            if (!\class_exists($enum) || !\in_array(Enum::class, \class_parents($enum), true)) {
                throw new base\InvalidConfigException("Class [{$enum}] must exist and implement " . Enum::class);
            }
        }
    }

    protected function isUseKey(string $attribute): bool
    {
        return \in_array($attribute, $this->useKeyFor, \true);
    }
}