Bdf\Prime\Entity\Hydrator\Generator\AttributesResolver

Complexity

Total Complexity

42

Size/Duplication

Total Lines	316
Duplicated Lines	0 %

Test Coverage

Coverage

98.06%

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	isImportable()	0	3	1
A	rootEmbedded()	0	3	1
A	hasRootEmbedded()	0	3	1
A	embedded()	0	3	1
A	rootAttributes()	0	3	1
A	buildRootAttributes()	0	18	4
B	resolveClassesFromRelation()	0	36	9
A	buildMetadataProperties()	0	8	3
A	buildRootEmbeddeds()	0	5	5
A	embeddeds()	0	3	1
A	className()	0	3	1
A	attribute()	0	3	1
A	rootEmbeddeds()	0	3	1
A	build()	0	6	1
B	buildRelationEmbeddeds()	0	38	8
A	isEntity()	0	3	1
A	attributes()	0	3	1

<?php

namespace Bdf\Prime\Entity\Hydrator\Generator;

use Bdf\Prime\Entity\Hydrator\Exception\HydratorGenerationException;
use Bdf\Prime\Entity\ImportableInterface;
use Bdf\Prime\Mapper\Mapper;
use Bdf\Prime\Mapper\SingleTableInheritanceMapper;
use Bdf\Prime\Relations\RelationInterface;
use Bdf\Prime\ServiceLocator;

/**
 * Resolve attributes and embedded objects from Mapper
 */
class AttributesResolver
{
    /**
     * @var Mapper
     */
    private $mapper;

    /**
     * @var ServiceLocator
     */
    private $prime;

    /**
     * List of all attributes of the entity
     *
     * @var AttributeInfo[]
     */
    private $attributes = [];

    /**
     * List of all embedded entities
     *
     * @var EmbeddedInfo[]
     */
    private $embeddeds = [];

    /**
     * @var AttributeInfo[]
     */
    private $rootAttributes = [];

    /**
     * @var EmbeddedInfo[]
     */
    private $rootEmbeddeds = [];


    /**
     * AttributesResolver constructor.
     *
     * @param Mapper $mapper
     * @param ServiceLocator $prime
     *
     * @thorws HydratorException
     */
    public function __construct(Mapper $mapper, ServiceLocator $prime)

Expected 1 blank line before function; 2 found

    {
        $this->mapper = $mapper;
        $this->prime = $prime;

        $this->build();
    }

    /**
     * Get the root entity class name
     *
     * @return class-string

The doc comment class-string at position 0 could not be parsed: Unknown type name 'class-string' at position 0 in class-string.

Expected "classstring" but found "class-string" for function return type

     */
    public function className(): string
    {
        return $this->mapper->getEntityClass();
    }

    /**
     * @return AttributeInfo[]
     */
    public function attributes()
    {
        return $this->attributes;
    }

Expected 1 blank line after function; 2 found

    /**
     * @param string $name
     *
     * @return AttributeInfo
     */
    public function attribute($name)
    {
        return $this->attributes[$name];
    }

    /**
     * @return EmbeddedInfo[]
     */
    public function embeddeds()
    {
        return $this->embeddeds;
    }

    /**
     * Get the embedded entity info
     *
     * @param string $attribute The attribute path
     *
     * @return EmbeddedInfo
     */
    public function embedded($attribute)
    {
        return $this->embeddeds[$attribute];
    }

    /**
     * Get the embedded entity info
     *
     * @param string $attribute The attribute path
     *
     * @return EmbeddedInfo
     */
    public function rootEmbedded($attribute)
    {
        return $this->rootEmbeddeds[$attribute];
    }

    /**
     * Get all "root" embeddeds
     *
     * @return EmbeddedInfo[]
     */
    public function rootEmbeddeds()
    {
        return $this->rootEmbeddeds;
    }

    /**
     * Check if the root embedded exists
     *
     * @param string $attribute The attribute path
     *
     * @return bool

Expected "boolean" but found "bool" for function return type

     */
    public function hasRootEmbedded($attribute)
    {
        return isset($this->rootEmbeddeds[$attribute]);
    }

    /**
     * Get all the "root" attributes (not defined into an embedded, or the root embedded property)
     *
     * @return AttributeInfo[]
     */
    public function rootAttributes()
    {
        return $this->rootAttributes;
    }

    /**
     * Does the class is an entity
     * Means could have a hydrator
     *
     * @param string $class
     *
     * @return bool

Expected "boolean" but found "bool" for function return type

     */
    public function isEntity($class)
    {
        return $this->prime->mappers()->isEntity($class);
    }

    /**
     * Does the class implements importable interface
     *
     * @param string $class
     *
     * @return bool

Expected "boolean" but found "bool" for function return type

     */
    public function isImportable($class)
    {
        return is_subclass_of($class, ImportableInterface::class);
    }

    /**
     * Build the attributes and embedded info
     *
     * @thows HydratorException
     */
    private function build()

Private method name "AttributesResolver::build" must be prefixed with an underscore

    {
        $this->buildMetadataProperties();
        $this->buildRootAttributes();
        $this->buildRootEmbeddeds();
        $this->buildRelationEmbeddeds();
    }

    private function buildMetadataProperties()

Missing doc comment for function buildMetadataProperties()

Private method name "AttributesResolver::buildMetadataProperties" must be prefixed with an underscore

Missing function doc comment

    {
        foreach ($this->mapper->metadata()->attributes() as $name => $meta) {
            $this->attributes[$name] = new AttributeInfo($name, $meta, $this);
        }

        foreach ($this->mapper->metadata()->embeddeds() as $name => $meta) {
            $this->embeddeds[$name] = new EmbeddedInfo($name, $meta, $this);
        }
    }

    private function buildRootAttributes()

Missing doc comment for function buildRootAttributes()

Private method name "AttributesResolver::buildRootAttributes" must be prefixed with an underscore

Missing function doc comment

    {
        foreach ($this->attributes as $attribute) {
            if ($attribute->isEmbedded()) {
                //Find only the "root" embedded attribute

No space found before comment text; expected "// Find only the "root" embedded attribute" but found "//Find only the "root" embedded attribute"

                $rootAttribue = $attribute->embedded()->rootAttribute();

                if (isset($this->rootAttributes[$rootAttribue])) {
                    continue;
                }

                $attribute = $this->attributes[$rootAttribue] ?? new AttributeInfo($rootAttribue, [

Operation must be bracketed

                    'embedded' => $rootAttribue,
                    'root'     => true,
                ], $this);
            }

            $this->rootAttributes[$attribute->name()] = $attribute;
        }
    }

    private function buildRootEmbeddeds()

Private method name "AttributesResolver::buildRootEmbeddeds" must be prefixed with an underscore

Missing function doc comment

Missing doc comment for function buildRootEmbeddeds()

    {
        foreach ($this->embeddeds as $embedded) {
            if ($embedded->isRoot() && ($embedded->isEntity() || $embedded->isImportable())) {
                $this->rootEmbeddeds[$embedded->path()] = $embedded;
            }
        }
    }

    /**
     * @throws HydratorGenerationException
     */
    private function buildRelationEmbeddeds()

Private method name "AttributesResolver::buildRelationEmbeddeds" must be prefixed with an underscore

    {
        foreach ($this->mapper->relations()->relations() as $name => $relation) {
            if (!empty($relation['detached'])) {
                unset($this->rootEmbeddeds[$name]);
                continue;
            }

            // "MANY" relations are stored as array, so cannot be hydrated
            if (!in_array($relation['type'], [RelationInterface::HAS_MANY, RelationInterface::BELONGS_TO_MANY])) {
                $this->rootEmbeddeds[$name] = new EmbeddedInfo($name, [
                    'parentPath' => 'root',
                    'path'       => $name,
                    'paths'      => [$name],
                    'classes'    => $this->resolveClassesFromRelation($relation, $name),
                ], $this);
            } elseif (

Usage of ELSEIF not allowed; use ELSE IF instead

Expected 0 spaces after opening bracket; newline found

First condition of a multi-line IF statement must directly follow the opening parenthesis

                !empty($relation['wrapper'])

Each line in a multi-line IF statement must begin with a boolean operator

                && is_subclass_of($wrapperClass = $this->prime->repository($relation['entity'])->collectionFactory()->wrapperClass($relation['wrapper']), ImportableInterface::class)

Variable assignment found within a condition. Did you mean to do a comparison ?

Assignments must be the first block of code on a line

            ) {
                $this->rootEmbeddeds[$name] = new EmbeddedInfo($name, [
                    'parentPath' => 'root',
                    'path'       => $name,
                    'paths'      => [$name],
                    'class'      => $wrapperClass,
                ], $this);
            } else {
                unset($this->rootEmbeddeds[$name]);
            }

            if (!isset($this->rootAttributes[$name])) {
                $attributeMetadata = ['root' => true];

                if (isset($this->rootEmbeddeds[$name])) {
                    $attributeMetadata['embedded'] = $name;
                }

                $this->rootAttributes[$name] = new AttributeInfo($name, $attributeMetadata, $this);
            }
        }

End comment for long condition not found; expected "//end foreach"

    }

    /**
     * Resolve entities classes from one relation
     *
     * @param array $relation The relation metadata
     * @param string $relationName The relation name
     *
     * @return string[] List of entities classes
     *
     * @throws HydratorGenerationException
     */
    private function resolveClassesFromRelation(array $relation, $relationName)

Private method name "AttributesResolver::resolveClassesFromRelation" must be prefixed with an underscore

    {
        switch ($relation['type']) {
            case RelationInterface::HAS_ONE:
            case RelationInterface::BELONGS_TO:
                return [$relation['entity']];

Case breaking statement indented incorrectly; expected 14 spaces, found 16

            case RelationInterface::MORPH_TO:
                $classes = [];

                foreach ($relation['map'] as $name => $entity) {
                    if (is_array($entity)) {
                        $classes[] = $entity['entity'];
                    } else {
                        $classes[] = explode('::', $entity, 2)[0];
                    }
                }

Blank line found after control structure

                return $classes;

Case breaking statement indented incorrectly; expected 14 spaces, found 16

            case RelationInterface::BY_INHERITANCE:
                if (!$this->mapper instanceof SingleTableInheritanceMapper) {
                    throw new HydratorGenerationException($this->mapper->getEntityClass(), "The mapper should be a subclass of SingleTableInheritanceMapper for use 'by inheritance' relation");
                }

                $classes = [];

                foreach ($this->mapper->getEntityMap() as $entityClass) {
                    $subMapper = $this->prime->mappers()->build($this->prime, $entityClass);
                    $classes = array_merge($classes, $this->resolveClassesFromRelation($subMapper->relations()->relations()[$relationName], $relationName));
                }

Blank line found after control structure

                return array_unique($classes);

Case breaking statement indented incorrectly; expected 14 spaces, found 16

            default:
                throw new HydratorGenerationException($this->mapper->getEntityClass(), 'Cannot handle relation type ' . $relation['type']);

Case breaking statement indented incorrectly; expected 14 spaces, found 16

        }

End comment for long condition not found; expected "//end switch"

    }
}