Apie::getResourceSerializer() - Code Metrics - Inspection of "wip - initial commit Apie plugins" - pjordaan/apie - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Branch — 3.0.0 (80e4da)

by Pieter
created 2020-01-28 14:43 UTC
Apie::getResourceSerializer() A

↳ Parent: Apie
Complexity

Conditions	2
Paths	2
Size

Total Lines	6
Code Lines	3
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	2
eloc	3
c	1
b	0
f	0
nc	2
nop	0
dl	0
loc	6
rs	10
<?php

namespace W2w\Lib\Apie;

use Doctrine\Common\Annotations\Reader;
use Psr\Cache\CacheItemPoolInterface;
use Symfony\Component\PropertyAccess\PropertyAccessor;
use Symfony\Component\PropertyInfo\PropertyTypeExtractorInterface;
use Symfony\Component\Serializer\Encoder\DecoderInterface;
use Symfony\Component\Serializer\Encoder\EncoderInterface;
use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactoryInterface;
use Symfony\Component\Serializer\NameConverter\NameConverterInterface;
use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
use W2w\Lib\Apie\Exceptions\BadConfigurationException;
use W2w\Lib\Apie\Exceptions\NotAnApiePluginException;
use W2w\Lib\Apie\PluginInterfaces\AnnotationReaderProviderInterface;
use W2w\Lib\Apie\PluginInterfaces\ApieAwareInterface;
use W2w\Lib\Apie\PluginInterfaces\CacheItemPoolProviderInterface;
use W2w\Lib\Apie\PluginInterfaces\EncoderProviderInterface;
use W2w\Lib\Apie\PluginInterfaces\NormalizerProviderInterface;
use W2w\Lib\Apie\PluginInterfaces\ResourceProviderInterface;
use W2w\Lib\Apie\PluginInterfaces\SerializerProviderInterface;
use W2w\Lib\Apie\PluginInterfaces\SymfonyComponentProviderInterface;
use W2w\Lib\Apie\Plugins\CorePlugin;
use W2w\Lib\Apie\Serializers\ResourceSerializerInterface;

final class Apie implements SerializerProviderInterface, ResourceProviderInterface, NormalizerProviderInterface, EncoderProviderInterface, SymfonyComponentProviderInterface, CacheItemPoolProviderInterface, AnnotationReaderProviderInterface
{
    /**
     * @var bool
     */
    private $debug;

    /**
     * @var string|null
     */
    private $cacheFolder;

    /**
     * @var SerializerProviderInterface[]
     */
    private $serializers = [];

    /**
     * @var ResourceProviderInterface[]
     */
    private $resources = [];

    /**
     * @var NormalizerProviderInterface[]
     */
    private $normalizers = [];

    /**
     * @var EncoderProviderInterface[]
     */
    private $encoders = [];

    /**
     * @var SymfonyComponentProviderInterface[]
     */
    private $symfonyComponents = [];

    /**
     * @var CacheItemPoolProviderInterface[]
     */
    private $cacheItemPools = [];

    /**
     * @var object[]
     */
    private $plugins = [];

    /**
     * @var AnnotationReaderProviderInterface[]
     */
    private $annotationReaders = [];

    /**

     * @param object[] $plugins
     * @param bool $debug
     * @param string|null $cacheFolder
     * @param bool $addCorePlugin
     */
    public function __construct(array $plugins, bool $debug = false, ?string $cacheFolder = null, bool $addCorePlugin = true)
    {
        $this->debug = $debug;
        $this->cacheFolder = $cacheFolder;
        static $mapping = [
            SerializerProviderInterface::class => 'serializers',
            ResourceProviderInterface::class => 'resources',
            NormalizerProviderInterface::class => 'normalizers',
            EncoderProviderInterface::class => 'encoders',
            SymfonyComponentProviderInterface::class => 'symfonyComponents',
            CacheItemPoolProviderInterface::class => 'cacheItemPools',
            AnnotationReaderProviderInterface::class => 'annotationReaders',
        ];
        if ($addCorePlugin) {
            $plugins[] = new CorePlugin();
        }
        $this->plugins = $plugins;
        foreach ($plugins as $plugin) {
            $isUsed = false;
            foreach ($mapping as $className => $propertyName) {
                if ($plugin instanceof $className) {
                    $this->$propertyName[] = $plugin;
                    if (!$isUsed && $plugin instanceof ApieAwareInterface) {
                        $plugin->setApie($this);
                    }
                    $isUsed = true;
                }
            }
            if (!$isUsed) {
                throw new NotAnApiePluginException($plugin);
            }

        }
    }

    /**
     * @return bool
     */
    public function isDebug(): bool
    {
        return $this->debug;
    }

    /**
     * @return string|null
     */
    public function getCacheFolder(): ?string
    {
        return $this->cacheFolder;
    }

    public function getPlugin(string $pluginClass): object
    {
        foreach ($this->plugins as $plugin) {
            if ($plugin instanceof $pluginClass) {
                return $plugin;
            }
        }
        throw new BadConfigurationException('Plugin ' . $pluginClass . ' not found!');
    }

    /**
     * @return ResourceSerializerInterface
     */
    public function getResourceSerializer(): ResourceSerializerInterface
    {
        if (empty($this->serializers)) {
            throw new BadConfigurationException('I have no resource serializer set up');
        }
        return reset($this->serializers)->getResourceSerializer();
    }

    /**
     * Returns a list of Api resources.
     *
     * @param string $context
     * @return string[]
     */
    public function getResources(string $context): array
    {
        $resources = [];
        foreach ($this->resources as $resourceProvider) {
            $resources = array_merge($resources, $resourceProvider->getResources($context));
        }
        return array_values(array_unique($resources));
    }

    /**
     * @return NormalizerInterface[]|DenormalizerInterface[]
     */
    public function getNormalizers(): array
    {
        $normalizers = [];
        foreach ($this->normalizers as $normalizerProvider) {
            $normalizers = array_merge($normalizers, $normalizerProvider->getNormalizers());
        }
        return $normalizers;
    }

    /**
     * @return EncoderInterface[]|DecoderInterface[]
     */
    public function getEncoders(): array
    {
        $encoders = [];
        foreach ($this->encoders as $encoderProvider) {
            $encoders = array_merge($encoders, $encoderProvider->getNormalizers());
            $encoders = array_merge($encoders, $encoderProvider->/** @scrutinizer ignore-call */ getNormalizers());
        }
        return $encoders;
    }

    public function getClassMetadataFactory(): ClassMetadataFactoryInterface
    {
        if (empty($this->symfonyComponents)) {
            throw new BadConfigurationException('I have no symfony component provider set up');
        }
        return reset($this->symfonyComponents)->getClassMetadataFactory();
    }

    public function getPropertyConverter(): NameConverterInterface
    {
        if (empty($this->symfonyComponents)) {
            throw new BadConfigurationException('I have no symfony component provider set up');
        }
        return reset($this->symfonyComponents)->getPropertyConverter();
    }

    public function getPropertyAccessor(): PropertyAccessor
    {
        if (empty($this->symfonyComponents)) {
            throw new BadConfigurationException('I have no symfony component provider set up');
        }
        return reset($this->symfonyComponents)->getPropertyAccessor();
    }

    public function getPropertyTypeExtractor(): PropertyTypeExtractorInterface
    {
        if (empty($this->symfonyComponents)) {
            throw new BadConfigurationException('I have no symfony component provider set up');
        }
        return reset($this->symfonyComponents)->getPropertyTypeExtractor();
    }

    public function getCacheItemPool(): CacheItemPoolInterface
    {
        if (empty($this->cacheItemPools)) {
            throw new BadConfigurationException('I have no cache item pool provider set up');
        }
        return reset($this->cacheItemPools)->getCacheItemPool();
    }

    public function getAnnotationReader(): Reader
    {
        if (empty($this->annotationReaders)) {
            throw new BadConfigurationException('I have no annotation reader set up');
        }
        return reset($this->annotationReaders)->getAnnotationReader();
    }
}

pjordaan / apie

Branch — 3.0.0 (80e4da)

Apie::getResourceSerializer() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
