Knp\FriendlyContexts\Doctrine\EntityResolver

Complexity

Total Complexity

26

Size/Duplication

Total Lines	133
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	6

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	getMetadataFromProperty()	0	21	4
A	getMetadataFromObject()	0	7	1
A	entityNameProposal()	0	8	1
A	asAccessForCase()	0	6	2
A	getMappingFromMetadata()	0	10	3
B	getMappingFromMetadataPart()	0	15	5
A	resolve()	0	17	4
B	getClassesFromName()	0	26	5

<?php

namespace Knp\FriendlyContexts\Doctrine;

use Doctrine\Common\Inflector\Inflector;
use Doctrine\Common\Persistence\ObjectManager;
use Doctrine\ORM\Mapping\ClassMetadata;
use Knp\FriendlyContexts\Reflection\ObjectReflector;
use Knp\FriendlyContexts\Utils\TextFormater;

class EntityResolver
{
    const CASE_CAMEL      = 'CamelCase';
    const CASE_UNDERSCORE = 'UnderscoreCase';

    protected $reflector;
    protected $formater;

    public function __construct(ObjectReflector $reflector, TextFormater $formater)
    {
        $this->reflector = $reflector;
        $this->formater  = $formater;
    }

    public function resolve(ObjectManager $entityManager, $name, $namespaces = '')
    {
        $results = [];

        $namespaces = is_array($namespaces) ? $namespaces : [ $namespaces ];

        foreach ($namespaces as $namespace) {
            $results = $this->getClassesFromName($entityManager, $name, $namespace, $results);
        }

        if (0 === count($results)) {

            return;
        }

        return $results;
    }

    protected function getClassesFromName(ObjectManager $entityManager, $name, $namespace, array $results = [])
    {
        if (!empty($results)) {

            return $results;
        }

        $allMetadata = $entityManager->getMetadataFactory()->getAllMetadata();
        $allClass = $this->reflector->getReflectionsFromMetadata($allMetadata);

Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space

        foreach ($this->entityNameProposal($name) as $name) {
            $class = array_filter(
                $allClass,
                function ($e) use ($namespace, $name) {
                    $nameValid = strtolower($e->getShortName()) === strtolower($name);

                    return '' === $namespace
                        ? $nameValid
                        : $namespace === substr($e->getNamespaceName(), 0, strlen($namespace)) && $nameValid
                    ;
                }
            );
            $results = array_merge($results, $class);
        }

        return $results;
    }

    public function getMetadataFromProperty(ObjectManager $entityManager, $entity, $property)

The return type could not be reliably inferred; please add a @return annotation.

    {
        $metadata = $this->getMetadataFromObject($entityManager, $entity);

        if (null !== $map = $this->getMappingFromMetadata($metadata, $property)) {

$metadata of type object<Doctrine\Common\Persistence\Mapping\ClassMetadata> is not a sub-type of object<Doctrine\ORM\Mapping\ClassMetadata>. It seems like you assume a concrete implementation of the interface Doctrine\Common\Persistence\Mapping\ClassMetadata to be always present.

            return $map;
        }

        if ($this->asAccessForCase($entity, $property, self::CASE_CAMEL) || $this->asAccessForCase($entity, $property, self::CASE_UNDERSCORE)) {
            return false;
        }

        throw new \RuntimeException(
            sprintf(
                'Can\'t find property %s or %s in class %s',
                $this->formater->toCamelCase(strtolower($property)),
                $this->formater->toUnderscoreCase(strtolower($property)),
                get_class($entity)
            )
        );
    }

    public function getMetadataFromObject(ObjectManager $entityManager, $object)
    {
        return $entityManager
            ->getMetadataFactory()
            ->getMetadataFor(get_class($object)
        );
    }

    public function entityNameProposal($name)
    {
        $name = strtolower(str_replace(" ", "", $name));

The string literal does not require double quotes, as per coding-style, please use single quotes.

The string literal does not require double quotes, as per coding-style, please use single quotes.

        $results = [Inflector::singularize($name), Inflector::pluralize($name), $name];

        return array_unique($results);
    }

    public function asAccessForCase($entity, $property, $case)
    {
        $method = sprintf('to%s', $case);

        return property_exists($entity, $this->formater->{$method}($property)) || method_exists($entity, 'set' . $this->formater->{$method}($property));
    }

    protected function getMappingFromMetadata(ClassMetadata $metadata, $property)

The return type could not be reliably inferred; please add a @return annotation.

    {
        if (null !== $map = $this->getMappingFromMetadataPart($metadata->fieldMappings, $property)) {
            return $map;
        }

        if (null !== $map = $this->getMappingFromMetadataPart($metadata->associationMappings, $property)) {
            return $map;
        }
    }

    protected function getMappingFromMetadataPart($metadata, $property)

The return type could not be reliably inferred; please add a @return annotation.

    {
        $property = trim($property);

        foreach ($metadata as $id => $map) {
            switch (strtolower($id)) {
                case strtolower($property):
                case strtolower($this->formater->toCamelCase($property)):
                case strtolower($this->formater->toUnderscoreCase($property)):
                    return $map;
            }
        }

        return null;
    }

}