Apie\CorePlugin\ResourceFactories\FallbackFactory

Complexity

Total Complexity

20

Size/Duplication

Total Lines	104
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	getApiResourcePersisterInstance()	0	10	3
A	createClassWithoutConstructorArguments()	0	11	4
A	hasApiResourceRetrieverInstance()	0	3	2
A	__construct()	0	6	1
A	getApiResourceRetrieverInstance()	0	10	3
A	isClassWithoutConstructorArguments()	0	8	3
A	hasApiResourcePersisterInstance()	0	3	2
A	getMemoryDataLayer()	0	9	2

<?php

namespace Apie\CorePlugin\ResourceFactories;

use Apie\Core\Exceptions\CouldNotConstructApiResourceClassException;
use Apie\Core\Exceptions\InvalidClassTypeException;
use Apie\Core\IdentifierExtractor;
use Apie\Core\Interfaces\ApiResourceFactoryInterface;
use Apie\Core\Interfaces\ApiResourcePersisterInterface;
use Apie\Core\Interfaces\ApiResourceRetrieverInterface;
use Apie\CorePlugin\DataLayers\MemoryDataLayer;
use Apie\ObjectAccessNormalizer\ObjectAccess\ObjectAccessInterface;
use ReflectionClass;
use ReflectionException;

class FallbackFactory implements ApiResourceFactoryInterface
{
    private $propertyAccessor;

    private $identifierExtractor;

    private $memoryDataLayer;

    public function __construct(
        ObjectAccessInterface $propertyAccessor,
        IdentifierExtractor $identifierExtractor
    ) {
        $this->propertyAccessor = $propertyAccessor;
        $this->identifierExtractor = $identifierExtractor;
    }

    private function getMemoryDataLayer(): MemoryDataLayer
    {
        if (!$this->memoryDataLayer) {
            $this->memoryDataLayer = new MemoryDataLayer(
                $this->propertyAccessor,
                $this->identifierExtractor
            );
        }
        return $this->memoryDataLayer;
    }

    /**
     * Returns true if this factory can create this identifier.
     *
     * @param string $identifier
     * @return bool
     */
    public function hasApiResourceRetrieverInstance(string $identifier): bool
    {
        return  $identifier === MemoryDataLayer::class || $this->isClassWithoutConstructorArguments($identifier);
    }

    /**
     * Gets an instance of ApiResourceRetrieverInstance
     * @param string $identifier
     * @return ApiResourceRetrieverInterface
     */
    public function getApiResourceRetrieverInstance(string $identifier): ApiResourceRetrieverInterface
    {
        if ($identifier === MemoryDataLayer::class) {
            return $this->getMemoryDataLayer();
        }
        $retriever = $this->createClassWithoutConstructorArguments($identifier);
        if (!$retriever instanceof ApiResourceRetrieverInterface) {
            throw new InvalidClassTypeException($identifier, 'ApiResourceRetrieverInterface');
        }
        return $retriever;
    }

    /**
     * Returns true if this factory can create this identifier.
     *
     * @param string $identifier
     * @return bool
     */
    public function hasApiResourcePersisterInstance(string $identifier): bool
    {
        return $identifier === MemoryDataLayer::class || $this->isClassWithoutConstructorArguments($identifier);
    }

    /**
     * Gets an instance of ApiResourceRetrieverInstance
     * @param string $identifier
     * @return ApiResourcePersisterInterface
     */
    public function getApiResourcePersisterInstance(string $identifier): ApiResourcePersisterInterface
    {
        if ($identifier === MemoryDataLayer::class) {
            return $this->getMemoryDataLayer();
        }
        $retriever = $this->createClassWithoutConstructorArguments($identifier);
        if (!$retriever instanceof ApiResourcePersisterInterface) {
            throw new InvalidClassTypeException($identifier, 'ApiResourcePersisterInterface');
        }
        return $retriever;
    }

    private function isClassWithoutConstructorArguments(string $identifier): bool
    {
        try {
            $reflClass = new ReflectionClass($identifier);
        } catch (ReflectionException $reflectionException) {
            return false;
        }
        return !$reflClass->getConstructor() || $reflClass->getConstructor()->getNumberOfRequiredParameters() === 0;
    }

    private function createClassWithoutConstructorArguments(string $identifier): object
    {
        try {
            $reflClass = new ReflectionClass($identifier);
        } catch (ReflectionException $reflectionException) {
            throw new CouldNotConstructApiResourceClassException($identifier, $reflectionException);
        }
        if ($reflClass->getConstructor() && $reflClass->getConstructor()->getNumberOfRequiredParameters() > 0) {
            throw new CouldNotConstructApiResourceClassException($identifier);
        }
        return new $identifier();
    }
}