CorePlugin::getNormalizers() - 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
CorePlugin::getNormalizers() A

↳ Parent: CorePlugin
Complexity

Conditions	1
Paths	1
Size

Total Lines	33
Code Lines	24
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	1
eloc	24
c	1
b	0
f	0
nc	1
nop	0
dl	0
loc	33
rs	9.536
<?php


namespace W2w\Lib\Apie\Plugins;


use Doctrine\Common\Annotations\AnnotationReader;
use Doctrine\Common\Annotations\AnnotationRegistry;
use Doctrine\Common\Annotations\CachedReader;
use Doctrine\Common\Annotations\Reader;
use Doctrine\Common\Cache\PhpFileCache;
use Psr\Cache\CacheItemPoolInterface;
use Symfony\Component\Cache\Adapter\ArrayAdapter;
use Symfony\Component\PropertyAccess\PropertyAccess;
use Symfony\Component\PropertyAccess\PropertyAccessor;
use Symfony\Component\PropertyInfo\Extractor\PhpDocExtractor;
use Symfony\Component\PropertyInfo\Extractor\ReflectionExtractor;
use Symfony\Component\PropertyInfo\Extractor\SerializerExtractor;
use Symfony\Component\PropertyInfo\PropertyInfoExtractor;
use Symfony\Component\PropertyInfo\PropertyTypeExtractorInterface;
use Symfony\Component\Serializer\Mapping\ClassDiscriminatorFromClassMetadata;
use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactory;
use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactoryInterface;
use Symfony\Component\Serializer\Mapping\Loader\AnnotationLoader;
use Symfony\Component\Serializer\Mapping\Loader\LoaderChain;
use Symfony\Component\Serializer\NameConverter\CamelCaseToSnakeCaseNameConverter;
use Symfony\Component\Serializer\NameConverter\MetadataAwareNameConverter;
use Symfony\Component\Serializer\NameConverter\NameConverterInterface;
use Symfony\Component\Serializer\Normalizer\ArrayDenormalizer;
use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
use Symfony\Component\Serializer\Normalizer\JsonSerializableNormalizer;
use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
use Symfony\Component\Serializer\Serializer;
use W2w\Lib\Apie\ApiResources\ApplicationInfo;
use W2w\Lib\Apie\ApiResources\Status;
use W2w\Lib\Apie\BaseGroupLoader;
use W2w\Lib\Apie\ExtendReaderWithConfigReader;
use W2w\Lib\Apie\Normalizers\ApieObjectNormalizer;
use W2w\Lib\Apie\Normalizers\ContextualNormalizer;
use W2w\Lib\Apie\Normalizers\EvilReflectionPropertyNormalizer;
use W2w\Lib\Apie\Normalizers\ExceptionNormalizer;
use W2w\Lib\Apie\PluginInterfaces\AnnotationReaderProviderInterface;
use W2w\Lib\Apie\PluginInterfaces\ApieAwareInterface;
use W2w\Lib\Apie\PluginInterfaces\ApieAwareTrait;
use W2w\Lib\Apie\PluginInterfaces\CacheItemPoolProviderInterface;
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\Serializers\ResourceSerializerInterface;
use W2w\Lib\Apie\Serializers\SymfonySerializerAdapter;

class CorePlugin implements SerializerProviderInterface, ResourceProviderInterface, ApieAwareInterface, NormalizerProviderInterface, SymfonyComponentProviderInterface, CacheItemPoolProviderInterface, AnnotationReaderProviderInterface
{
    use ApieAwareTrait;

    private $classMetadataFactory;

    private $propertyConverter;

    private $propertyAccessor;

    private $propertyTypeExtractor;

    private $annotationReader;

    /**
     * Returns a list of Api resources.
     *
     * @param string $context
     * @return string[]
     */
    public function getResources(string $context): array
    {
        return [ApplicationInfo::class, Status::class];
    }

    public function getResourceSerializer(): ResourceSerializerInterface
    {
        $normalizers = $this->getApie()->getNormalizers();
        $encoders = $this->getApie()->getEncoders();
        $serializer = new Serializer($normalizers, $encoders);
        return new SymfonySerializerAdapter($serializer);
    }

    /**
     * @return NormalizerInterface[]|DenormalizerInterface[]
     */
    public function getNormalizers(): array
    {
        $classMetadataFactory = $this->getApie()->getClassMetadataFactory();

        $classDiscriminator = new ClassDiscriminatorFromClassMetadata($classMetadataFactory);

        $objectNormalizer = new ApieObjectNormalizer(
            $classMetadataFactory,
            $this->getApie()->getPropertyConverter(),
            $this->getApie()->getPropertyAccessor(),
            $this->getApie()->getPropertyTypeExtractor(),
            $classDiscriminator,
            null,
            []
        );
        $evilObjectNormalizer = new EvilReflectionPropertyNormalizer(
            $classMetadataFactory,
            $this->getApie()->getPropertyConverter(),
            $this->getApie()->getPropertyAccessor(),
            $this->getApie()->getPropertyTypeExtractor(),
            $classDiscriminator,
            null,
            []
        );
        ContextualNormalizer::disableDenormalizer(EvilReflectionPropertyNormalizer::class);
        ContextualNormalizer::disableNormalizer(EvilReflectionPropertyNormalizer::class);

        return [

            new ExceptionNormalizer($this->getApie()->isDebug()),
            new JsonSerializableNormalizer(),
            new ArrayDenormalizer(),
            new ContextualNormalizer([$evilObjectNormalizer]),
            $objectNormalizer
        ];

    }

    public function getClassMetadataFactory(): ClassMetadataFactoryInterface
    {
        if (!$this->classMetadataFactory) {
            $this->classMetadataFactory = new ClassMetadataFactory(
                new LoaderChain([
                    new AnnotationLoader($this->getApie()->getAnnotationReader()),
                    new BaseGroupLoader(['read', 'write', 'get', 'post', 'put']),
                ])
            );
        }
        return $this->classMetadataFactory;
    }

    public function getPropertyConverter(): NameConverterInterface
    {
        if (!$this->propertyConverter) {
            $classMetadataFactory = $this->getApie()->getClassMetadataFactory();
            $this->propertyConverter = new MetadataAwareNameConverter(
                $classMetadataFactory,
                new CamelCaseToSnakeCaseNameConverter()
            );
        }
        return $this->propertyConverter;
    }

    public function getPropertyAccessor(): PropertyAccessor
    {
        if (!$this->propertyAccessor) {
            $this->propertyAccessor = PropertyAccess::createPropertyAccessorBuilder()
                ->setCacheItemPool($this->getApie()->getCacheItemPool())
                ->getPropertyAccessor();
        }
        return $this->propertyAccessor;
    }

    public function getPropertyTypeExtractor(): PropertyTypeExtractorInterface
    {
        if (!$this->propertyTypeExtractor) {
            $factory = $this->getApie()->getClassMetadataFactory();
            $reflectionExtractor = new ReflectionExtractor();
            $phpDocExtractor = new PhpDocExtractor();

            $this->propertyTypeExtractor = new PropertyInfoExtractor(
                [
                    new SerializerExtractor($factory),
                    $reflectionExtractor,
                ],
                [
                    $phpDocExtractor,
                    $reflectionExtractor,
                ],
                [
                    $phpDocExtractor,
                ],
                [
                    $reflectionExtractor,
                ],
                [
                    $reflectionExtractor,
                ]
            );
        }
        return $this->propertyTypeExtractor;
    }

    public function getCacheItemPool(): CacheItemPoolInterface
    {
        return new ArrayAdapter(0, true);
    }

    /**
     * @return Reader
     */
    public function getAnnotationReader(): Reader
    {
        if (!$this->annotationReader) {
            /** @scrutinizer ignore-deprecated */AnnotationRegistry::registerLoader('class_exists');
            if (class_exists(PhpFileCache::class) && $this->getApie()->getCacheFolder()) {
                $this->annotationReader = new CachedReader(
                    new AnnotationReader(),
                    new PhpFileCache($this->getCacheFolder() . DIRECTORY_SEPARATOR . '/doctrine-cache'),
                    new PhpFileCache($this->/** @scrutinizer ignore-call */ getCacheFolder() . DIRECTORY_SEPARATOR . '/doctrine-cache'),
                    $this->isDebug()
                           isDebug()
                );
            } else {
                $this->annotationReader = new AnnotationReader();
            }
        }
        return $this->annotationReader;
    }
}

pjordaan / apie

Branch — 3.0.0 (80e4da)

CorePlugin::getNormalizers() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
