Tonic\Component\ApiLayer\ModelTransformer\ModelTransformer

Complexity

Total Complexity

51

Size/Duplication

Total Lines	237
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	3
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
C	findSupportedObjectTransformer()	0	24	7
C	addModelTransformer()	0	36	8
A	getObjectTransformers()	0	17	4
A	getModelTransformers()	0	14	3
C	supports()	0	27	11
D	transform()	0	31	9
C	findSupportedModelTransformer()	0	22	9

<?php

namespace Tonic\Component\ApiLayer\ModelTransformer;

use Tonic\Component\ApiLayer\ModelTransformer\Exception\UnsupportedTransformationException;

/**
 * Manages transformers.
 */
class ModelTransformer implements ModelTransformerInterface
{
    /**
     * @var ModelTransformerInterface[]|ContextualModelTransformerInterface[]
     */
    private $modelTransformers = [];

    /**
     * @var ObjectTransformerInterface[]
     */
    private $objectTransformers = [];

    /**
     * @var array
     */
    private $sortedModelTransformers = [];

    /**
     * @var array
     */
    private $sortedObjectTransformers = [];

    /**
     * @param ModelTransformerInterface $modelTransformer
     * @param int $priority
     *
     * @return $this|ModelTransformerInterface
     *
     * @throws \RuntimeException
     */
    public function addModelTransformer($modelTransformer, $priority = 0)
    {
        if (!(($modelTransformer instanceof ModelTransformerInterface)
            || ($modelTransformer instanceof ContextualModelTransformerInterface)
            || ($modelTransformer instanceof ObjectTransformerInterface)
        )
        ) {
            throw new \RuntimeException(
                sprintf('Model transformer should be an instance of "%s", "%s" or "%s"', ModelTransformerInterface::class, ContextualModelTransformerInterface::class, ObjectTransformerInterface::class)
            );
        }

        if ($modelTransformer instanceof ObjectTransformerInterface) {
            if (!isset($this->objectTransformers[$modelTransformer->getSupportedClass()])) {
                $this->objectTransformers[$modelTransformer->getSupportedClass()] = [];
            }

            if (!isset($this->objectTransformers[$modelTransformer->getSupportedClass()][$modelTransformer->getTargetClass()])) {
                $this->objectTransformers[$modelTransformer->getSupportedClass()][$modelTransformer->getTargetClass()] = [];
            }

            $this->objectTransformers[$modelTransformer->getSupportedClass()][$modelTransformer->getTargetClass()][$priority] = $modelTransformer;
            unset($this->sortedObjectTransformers);

            return $this;
        }

        if (!isset($this->modelTransformers[$priority])) {
            $this->modelTransformers[$priority] = [];
        }

        $this->modelTransformers[$priority][] = $modelTransformer;
        unset($this->sortedModelTransformers);

        return $this;
    }

    /**
     * @return ObjectTransformerInterface[]
     */
    public function getObjectTransformers()
    {
        if (isset($this->sortedObjectTransformers)) {
            return $this->sortedObjectTransformers;
        }

        $this->sortedObjectTransformers = [];
        foreach ($this->objectTransformers as $supportedClass => $objectTransformersBySupportedClass) {
            $this->sortedObjectTransformers[$supportedClass] = [];
            foreach ($objectTransformersBySupportedClass as $targetClass => $objectTransformersByPriorities) {

The expression $objectTransformersBySupportedClass of type object<Tonic\Component\ApiLayer\ModelTransformer\ObjectTransformerInterface> is not traversable.

                ksort($objectTransformersByPriorities);
                $this->sortedObjectTransformers[$supportedClass][$targetClass] = array_values($objectTransformersByPriorities)[0];
            }
        }

        return $this->sortedObjectTransformers;
    }

    /**
     * @return ModelTransformerInterface[]
     */
    public function getModelTransformers()
    {
        if (isset($this->sortedModelTransformers)) {
            return $this->sortedModelTransformers;
        }

        krsort($this->modelTransformers);
        $this->sortedModelTransformers = [];
        foreach ($this->modelTransformers as $modelTransformers) {
            $this->sortedModelTransformers = array_merge($this->sortedModelTransformers, $modelTransformers);
        }

        return $this->sortedModelTransformers;
    }

    /**
     * {@inheritdoc}
     */
    public function supports($object, $targetClass)
    {
        if (null === $object) {
            // transformation of nothing ot anything is nothing
            return true;
        }

        /** @var ContextInterface $context */
        $context = (func_num_args() == 3) ? func_get_arg(2) : null;

        $objectTransformers = $this->getObjectTransformers();
        if (is_object($object) && isset($objectTransformers[get_class($object)]) && isset($objectTransformers[get_class($object)][$targetClass])) {
            return true;
        }

        foreach ($this->getModelTransformers() as $modelTransformer) {
            if (($modelTransformer instanceof ContextualModelTransformerInterface) && $modelTransformer->supports($object, $targetClass, $context)) {
                return true;
            }

            if (($modelTransformer instanceof ModelTransformerInterface) && $modelTransformer->supports($object, $targetClass)) {
                return true;
            }
        }

        return false;
    }

    /**
     * {@inheritdoc}
     */
    public function transform($object, $targetClass)
    {
        if (null === $object) {
            // transformation of nothing ot anything is nothing
            return null;
        }

        /** @var ContextInterface $context */
        $context = (func_num_args() == 3) ? func_get_arg(2) : null;

        $modelTransformer = $this->findSupportedModelTransformer($object, $targetClass, $context);

        if (is_object($object) && ($modelTransformer instanceof ObjectTransformerInterface)) {
            return $modelTransformer->transform($object);
        }

        if ($modelTransformer instanceof ContextualModelTransformerInterface) {
            return $modelTransformer->transform($object, $targetClass, $context);
        }

        if (($modelTransformer instanceof ModelTransformerInterface) && $modelTransformer->supports($object, $targetClass)) {
            return $modelTransformer->transform($object, $targetClass);
        }

        $objectType = is_object($object) ? get_class($object) : gettype($object);
        throw new UnsupportedTransformationException(sprintf(
            'Can not transform object of type "%s" to object of type "%s"',
            $objectType,
            $targetClass
        ));
    }

    /**
     * Finds and returns model transformer which supports specified object and target class.
     *
     * @param object|array $object
     * @param string $targetClass
     * @param ContextInterface|null $context
     *
     * @return null|ModelTransformerInterface|ContextualModelTransformerInterface|ObjectTransformerInterface
     */
    public function findSupportedModelTransformer($object, $targetClass, ContextInterface $context = null)
    {
        if (is_object($object) && ($objectTransformer = $this->findSupportedObjectTransformer(get_class($object), $targetClass))) {
            return $objectTransformer;
        }

        foreach ($this->getModelTransformers() as $modelTransformer) {
            if (($modelTransformer instanceof ContextualModelTransformerInterface) && $modelTransformer->supports($object, $targetClass, $context)) {
                return $modelTransformer;
            }

            if (($modelTransformer instanceof ModelTransformerInterface) && $modelTransformer->supports($object, $targetClass)) {
                return $modelTransformer;
            }

            if ($modelTransformer instanceof ObjectTransformerInterface) {
                continue;
            }
        }

        return null;
    }

    /**
     * Tries to find supported object transformer.
     *
     * @param string $supportedClass
     * @param string $targetClass
     *
     * @return null|ObjectTransformerInterface
     */
    private function findSupportedObjectTransformer($supportedClass, $targetClass)
    {
        $objectTransformers = $this->getObjectTransformers();
        if (isset($objectTransformers[$supportedClass]) && isset($objectTransformers[$supportedClass][$targetClass])) {
            return $objectTransformers[$supportedClass][$targetClass];
        }

        $supportedReflectionClass = new \ReflectionClass($supportedClass);

        if ($supportedReflectionClass->getParentClass()
            && ($objectTransformer = $this->findSupportedObjectTransformer($supportedReflectionClass->getParentClass()->getName(), $targetClass))
        ) {
            return $objectTransformer;
        }

        $targetReflectionClass = new \ReflectionClass($targetClass);
        if ($targetReflectionClass->getParentClass()
            && ($objectTransformer = $this->findSupportedObjectTransformer($supportedClass, $targetReflectionClass->getParentClass()->getName()))
        ) {
            return $objectTransformer;
        }

        return null;
    }
}