Mikemirten\Component\JsonApi\Mapper\Definition\AnnotationDefinitionProvider

Complexity

Total Complexity

14

Size/Duplication

Total Lines	116
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

88.1%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getDefinition()	0	21	3
B	createRelationship()	0	24	4
A	handleIdentifier()	0	14	3
A	resoleType()	0	12	3

<?php
declare(strict_types = 1);

namespace Mikemirten\Component\JsonApi\Mapper\Definition;

use Doctrine\Common\Annotations\Reader;
use Mikemirten\Component\JsonApi\Mapper\Definition\Annotation\Relationship as RelationshipAnnotation;

/**
 * Annotation Definition Provider based on the Doctrine-Annotation library
 *
 * @package Mikemirten\Component\JsonApi\Mapper\Definition
 */
class AnnotationDefinitionProvider implements DefinitionProviderInterface
{
    /**
     * Doctrine annotation reader
     *
     * @var Reader
     */
    protected $reader;

    /**
     * AnnotationDefinitionProvider constructor.
     *
     * @param Reader $reader
     */
    public function __construct(Reader $reader)
    {
        $this->reader = $reader;
    }

    /**
     * {@inheritdoc}
     */
    public function getDefinition(string $class): Definition
    {
        $definition = new Definition();
        $reflection = new \ReflectionClass($class);

        foreach ($reflection->getProperties() as $property)
        {
            $relationshipAnnotation = $this->reader->getPropertyAnnotation(
                $property,
                RelationshipAnnotation::class
            );

            if ($relationshipAnnotation !== null) {
                $relationship = $this->createRelationship($relationshipAnnotation, $property);

                $definition->addRelationship($relationship);
            }
        }

        return $definition;
    }

    /**
     * Process relationship
     *
     * @param  RelationshipAnnotation $annotation
     * @param  \ReflectionProperty    $property
     * @return Definition
     */
    protected function createRelationship(RelationshipAnnotation $annotation, \ReflectionProperty $property): Relationship
    {
        $name = ($annotation->name === null)
            ? $property->getName()
            : $annotation->name;

        $type = $this->resoleType($annotation);

        $relationship = new Relationship($name, $type);

        $getter = ($annotation->getter === null)
            ? ('get' . ucfirst($name))
            : $annotation->getter;

        $relationship->setGetter($getter);

        if ($annotation->resourceType !== null) {
            $relationship->setResourceType($annotation->resourceType);
        }

        $this->handleIdentifier($annotation, $relationship);

        return $relationship;
    }

    /**
     * Handle identifier
     *
     * @param RelationshipAnnotation $annotation
     * @param Relationship           $relationship
     */
    protected function handleIdentifier(RelationshipAnnotation $annotation, Relationship $relationship)
    {
        if ($annotation->idGetter !== null) {
            $relationship->setIdentifierGetter($annotation->idGetter);
            return;
        }

        if ($annotation->idProperty !== null) {
            $getter = 'get' . ucfirst($annotation->idProperty);

            $relationship->setIdentifierGetter($getter);
            return;
        }
    }

    /**
     * Resolve type of relationship
     *
     * @param  RelationshipAnnotation $annotation
     * @return int
     */
    protected function resoleType(RelationshipAnnotation $annotation): int
    {
        if ($annotation->type === RelationshipAnnotation::TYPE_ONE) {
            return Relationship::TYPE_X_TO_ONE;
        }

        if ($annotation->type === RelationshipAnnotation::TYPE_MANY) {
            return Relationship::TYPE_X_TO_MANY;
        }

        throw new \LogicException(sprintf('Invalid type of relation "%s" defined.', $annotation->type));
    }
}