Igni\Storage\Mapping\MetaData\EntityMetaData

Complexity

Total Complexity

29

Size/Duplication

Total Lines	199
Duplicated Lines	0 %

Test Coverage

Coverage

85.71%

Importance

Changes

0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	getSource()	0	3	1
A	__construct()	0	5	1
A	isStorable()	0	3	2
A	getCustomHydratorClass()	0	3	1
A	setSource()	0	4	1
A	makeEmbed()	0	4	1
A	hasIdentifier()	0	3	1
A	definesCustomHydrator()	0	3	1
A	addProperty()	0	5	2
A	getProperty()	0	6	2
A	getIdentifier()	0	7	2
A	getHydratorClassName()	0	3	1
A	setCustomHydratorClass()	0	6	2
A	isEmbed()	0	3	1
A	definesProperties()	0	3	1
A	getClass()	0	3	1
A	getProperties()	0	3	1
A	__sleep()	0	8	1
A	getFields()	0	3	1
A	createInstance()	0	7	2
A	__wakeup()	0	8	3

<?php declare(strict_types=1);

namespace Igni\Storage\Mapping\MetaData;

use Igni\Storage\Exception\MappingException;
use Igni\Storage\Mapping\Strategy\Id;
use ReflectionClass;

/**
 * Keeps information how entity should be mapped.
 *
 * @package Igni\Storage\Mapping\MetaData
 */
final class EntityMetaData
{
    /**
     * Entity class (FQCN)
     * @var string
     */
    private $class;

    /**
     * Generated hydrator class name (not FQCN)
     * @var string string
     */
    private $hydratorClassName;

    /**
     * Entity's mapped properties metadata.
     * @var PropertyMetaData[]
     */
    private $properties = [];

    /**
     * @var ReflectionClass
     */
    private $reflectionClass;

    /**
     * Either name of table or connection or any other namespace
     * where entity is stored.
     * @var string
     */
    private $source;

    /**
     * Provides information if entity is embed entity.
     * @var bool
     */
    private $embed = true;

    /**
     * Keeps user defined hydrator's class (FQCN).
     * @var string
     */
    private $customHydrator;

    /**
     * Keeps mapped properties to storage fields.
     * @var string[]
     */
    private $fields = [];

    /**
     * Contains identifier property.
     * @var PropertyMetaData|null
     */
    private $identifier;

    /**
     * @param string $class
     *
     * @throws \ReflectionException
     */
    public function __construct(string $class)
    {
        $this->class = $class;
        $this->reflectionClass = new ReflectionClass($class);
        $this->hydratorClassName = '_' . str_replace('\\', '', $class) . 'Hydrator';
    }

    public function makeEmbed(): void
    {
        $this->source = null;
        $this->embed = true;
    }

    public function isEmbed(): bool
    {
        return $this->embed;
    }

    public function isStorable(): bool
    {
        return $this->source !== null && $this->hasIdentifier();
    }

    public function setSource(string $source): void
    {
        $this->source = $source;
        $this->embed = false;
    }

    public function getSource(): string
    {
        return $this->source;
    }

    public function setCustomHydratorClass(string $className): void
    {
        if (!class_exists($className)) {
            throw new MappingException("Cannot set parent hydrator, class (${className}) does not exists.");
        }
        $this->customHydrator = $className;
    }

    public function definesCustomHydrator(): bool
    {
        return $this->customHydrator !== null;
    }

    public function getCustomHydratorClass(): string
    {
        return $this->customHydrator;
    }

    public function getProperty(string $name): PropertyMetaData
    {
        if (!isset($this->properties[$name])) {
            throw new MappingException("Property ${name} is undefined.");
        }
        return $this->properties[$name];
    }

    public function addProperty(PropertyMetaData $property): void
    {
        $this->properties[$property->getName()] = $property;
        if ($property->getType() === Id::class) {
            $this->identifier = $property;
        }
    }

    public function hasIdentifier(): bool
    {
        return $this->identifier !== null;
    }

    public function getIdentifier(): PropertyMetaData
    {
        if (!$this->hasIdentifier()) {
            throw new MappingException("Entity {$this->class} defines no identifier.");
        }

        return $this->identifier;
    }

    public function getHydratorClassName(): string
    {
        return $this->hydratorClassName;
    }

    public function definesProperties(): bool
    {
        return !empty($this->properties);
    }

    /**
     * @return PropertyMetaData[]
     */
    public function getProperties(): array
    {
        return $this->properties;
    }

    public function getFields(): array
    {
        return $this->fields;
    }

    public function getClass(): string
    {
        return $this->class;
    }

    public function createInstance(...$arguments)
    {
        if ($arguments) {

The expression $arguments of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            return $this->reflectionClass->newInstanceArgs($arguments);
        }

        return $this->reflectionClass->newInstanceWithoutConstructor();
    }

    public function __sleep()
    {
        return [
            'class',
            'hydratorClassName',
            'properties',
            'source',
            'customHydrator',
        ];
    }

    public function __wakeup()
    {
        $this->reflectionClass = new ReflectionClass($this->class);

        foreach ($this->properties as $property) {
            $this->fields[] = $property->getFieldName();
            if ($property->getType() === Id::class) {
                $this->identifier = $property;
            }
        }
    }
}