Mado\QueryBundle\Component\Sherlock\CurrentMetaData

Complexity

Total Complexity

11

Size/Duplication

Total Lines	85
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	justEntitiesMetadata()	0	5	1
A	fromEntityManager()	0	3	1
A	__construct()	0	9	1
A	hasRelations()	0	3	1
A	extraction()	0	7	1
A	extractFieldsType()	0	6	1
A	getCurrentAssociationMapping()	0	3	1
A	extractFields()	0	6	1
A	getRelations()	0	15	3

<?php

namespace Mado\QueryBundle\Component\Sherlock;

use Doctrine\ORM\EntityManagerInterface;
use Mado\QueryBundle\Dictionary;
use Mado\QueryBundle\Services\StringParser;

class CurrentMetaData
{
    private $metadata;

    private $manager;

    private $currentMetadata;

    private function __construct(EntityManagerInterface $manager)
    {
        $this->manager = $manager;

        $metadata = $this->manager
            ->getMetaDataFactory()
            ->getAllMetaData();

        $this->metadata = $metadata;
    }

    public static function fromEntityManager(EntityManagerInterface $manager) : CurrentMetaData
    {
        return new self($manager);
    }

    public function justEntitiesMetadata() : array
    {
        return array_map(function ($item) {
            return $item->rootEntityName;
        }, $this->metadata);
    }

    public function extractFields($entityClass) : array
    {
        return $this->extraction(
            $entityClass,
            function ($item) {
                return Dictionary::getOperatorsFromDoctrineType($item);
            }
        );
    }

    public function extractFieldsType($entityClass) : array
    {
        return $this->extraction(
            $entityClass,
            function ($item) {
                return $item;
            }
        );
    }

    private function extraction($entityClass, callable $step) : array
    {
        $this->currentMetadata = $this->manager->getClassMetadata($entityClass);

        return array_map(function ($item) use ($step) {
            return $step($item['type']);
        }, $this->currentMetadata->fieldMappings);

Accessing fieldMappings on the interface Doctrine\Common\Persistence\Mapping\ClassMetadata suggest that you code against a concrete implementation. How about adding an instanceof check?

    }

    public function hasRelations() : bool
    {
        return count($this->getCurrentAssociationMapping()) > 0;
    }

    public function getCurrentAssociationMapping()
    {
        return $this->currentMetadata->associationMappings;
    }

    public function getRelations() : array
    {
        $relations = [];

        foreach ($this->getCurrentAssociationMapping() as $rel) {
            $relationName = $rel['inversedBy'] == ''
                ? $rel['mappedBy']
                : $rel['inversedBy'];

            $relations[$relationName] = StringParser::dotNotationFor(
                $rel['targetEntity']
            );
        }

        return $relations;
    }
}