Mikemirten\Component\JsonApi\Mapper\ObjectMapper

Complexity

Total Complexity

10

Size/Duplication

Total Lines	147
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

97.14%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
A	addHandler()	0	4	1
A	toResource()	0	16	2
A	toResourceIdentifier()	0	9	1
A	fromResource()	0	11	2
A	resolveType()	0	10	2
A	createContext()	0	6	1

<?php
declare(strict_types = 1);

namespace Mikemirten\Component\JsonApi\Mapper;

use Mikemirten\Component\JsonApi\Document\ResourceIdentifierObject;
use Mikemirten\Component\JsonApi\Document\ResourceObject;
use Mikemirten\Component\JsonApi\Mapper\Definition\DefinitionProviderInterface;
use Mikemirten\Component\JsonApi\Mapper\Handler\HandlerInterface;
use Mikemirten\Component\JsonApi\Mapper\Handler\IdentifierHandler\IdentifierHandlerInterface;
use Mikemirten\Component\JsonApi\Mapper\Handler\TypeHandler\TypeHandlerInterface;

/**
 * Object mapper.
 *
 * Maps data between object and resource of document.
 * Can be helpful for serialization of objects to JSON API document.
 *
 * Each handler responsible for certain part of resource (links, metadata, relationships...).
 * Identifier and type handlers are specific and required to resolve id and type of resource.
 * Other handlers are optional.
 *
 * @package Mikemirten\Component\JsonApi\Mapper
 */
class ObjectMapper
{
    /**
     * Provider of mapping definition
     *
     * @var DefinitionProviderInterface
     */
    protected $definitionProvider;

    /**
     * Required identifier handler
     * Must always be present regardless of other handlers
     *
     * @var IdentifierHandlerInterface
     */
    protected $identifierHandler;

    /**
     * Required type handler
     * Must always be present regardless of other handlers
     *
     * @var TypeHandlerInterface
     */
    protected $typeHandler;

    /**
     * Mapping handlers
     *
     * @var HandlerInterface[]
     */
    protected $handlers = [];

    /**
     * ObjectMapper constructor.
     *
     * @param DefinitionProviderInterface $definitionProvider
     * @param IdentifierHandlerInterface  $identifierHandler
     * @param TypeHandlerInterface        $typeHandler
     */
    public function __construct(
        DefinitionProviderInterface $definitionProvider,
        IdentifierHandlerInterface  $identifierHandler,
        TypeHandlerInterface        $typeHandler
    ) {
        $this->definitionProvider = $definitionProvider;
        $this->identifierHandler  = $identifierHandler;
        $this->typeHandler        = $typeHandler;
    }

    /**
     * Add mapping handler
     *
     * @param HandlerInterface $handler
     */
    public function addHandler(HandlerInterface $handler)
    {
        $this->handlers[] = $handler;
    }

    /**
     * Map object's data to resource
     *
     * @param  mixed $object
     * @return ResourceObject
     */
    public function toResource($object): ResourceObject
    {
        $context = $this->createContext(get_class($object));

        $id   = $this->identifierHandler->getIdentifier($object, $context);
        $type = $this->resolveType($object, $context);

        $resource = new ResourceObject($id, $type);

        foreach ($this->handlers as $handler)
        {
            $handler->toResource($object, $resource, $context);
        }

        return $resource;
    }

    /**
     * Map object's identification to resource-identifier
     *
     * @param  $object
     * @return ResourceIdentifierObject
     */
    public function toResourceIdentifier($object): ResourceIdentifierObject
    {
        $context = $this->createContext(get_class($object));

        $id   = $this->identifierHandler->getIdentifier($object, $context);
        $type = $this->resolveType($object, $context);

        return new ResourceIdentifierObject($id, $type);
    }

    /**
     * Map resource's data to provided object
     *
     * @param mixed $object
     * @param ResourceObject $resource
     */
    public function fromResource($object, ResourceObject $resource)
    {
        $context = $this->createContext(get_class($object));

        $this->identifierHandler->setIdentifier($object, $resource->getId(), $context);

        foreach ($this->handlers as $handler)
        {
            $handler->fromResource($object, $resource, $context);
        }
    }

    /**
     * Resolve type of resource
     *
     * @param  $object
     * @param  MappingContext $context
     * @return string
     */
    protected function resolveType($object, MappingContext $context): string
    {
        $definition = $context->getDefinition();

        if ($definition->hasType()) {
            return $definition->getType();
        }

        return $this->typeHandler->getType($object, $context);
    }

    /**
     * Create mapping context for given class
     *
     * @param  string $class
     * @return MappingContext
     */
    protected function createContext(string $class): MappingContext
    {
        $definition = $this->definitionProvider->getDefinition($class);

        return new MappingContext($this, $definition);
    }
}