SoapContainerBuilder::createSerializerBuilderFromContainer() - Code Metrics - Inspection of "disp" - goetas-webservices/soap-common - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( dba7cd...d89126 )

by Asmir
created 2021-01-03 14:52 UTC
createSerializerBuilderFromContainer() A

↳ Parent: SoapContainerBuilder
Complexity

Conditions	2
Paths	2
Size

Total Lines	11
Code Lines	6
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	6
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	2
eloc	6
nc	2
nop	4
dl	0
loc	11
rs	10
c	1
b	0
f	0
ccs	0
cts	9
cp	0
crap	6
<?php

declare(strict_types=1);

namespace GoetasWebservices\SoapServices\Metadata\Builder;

use GoetasWebservices\SoapServices\Metadata\DependencyInjection\Compiler\CleanupPass;
use GoetasWebservices\SoapServices\Metadata\Envelope\Envelope;
use GoetasWebservices\SoapServices\Metadata\Headers\Handler\HeaderHandler;
use GoetasWebservices\Xsd\XsdToPhpRuntime\Jms\Handler\BaseTypesHandler;
use GoetasWebservices\Xsd\XsdToPhpRuntime\Jms\Handler\XmlSchemaDateHandler;
use JMS\Serializer\EventDispatcher\EventDispatcherInterface;
use JMS\Serializer\Handler\HandlerRegistryInterface;
use JMS\Serializer\SerializerBuilder;
use Symfony\Component\Config\FileLocator;
filter:
    dependency_paths: ["lib/*"]
use Symfony\Component\Config\Loader\DelegatingLoader;
filter:
    dependency_paths: ["lib/*"]
use Symfony\Component\Config\Loader\LoaderResolver;
filter:
    dependency_paths: ["lib/*"]
use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
filter:
    dependency_paths: ["lib/*"]
use Symfony\Component\DependencyInjection\ContainerBuilder;
filter:
    dependency_paths: ["lib/*"]
use Symfony\Component\DependencyInjection\ContainerInterface;
filter:
    dependency_paths: ["lib/*"]
use Symfony\Component\DependencyInjection\Dumper\PhpDumper;
filter:
    dependency_paths: ["lib/*"]
use Symfony\Component\DependencyInjection\Extension\ExtensionInterface;
filter:
    dependency_paths: ["lib/*"]
use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
filter:
    dependency_paths: ["lib/*"]
use Symfony\Component\DependencyInjection\Loader\YamlFileLoader;
filter:
    dependency_paths: ["lib/*"]

abstract class SoapContainerBuilder
{
    /**
     * @var string
     */
    private $className = 'SoapContainer';

    /**
     * @var string
     */
    private $classNs = 'SoapServicesStub';

    /**
     * @var string
     */
    protected $configFile = 'config.yml';

    /**
     * @var string[]
     */
    protected $extensions = [];

    /**
     * @var string[]
     */
    protected $compilerPasses = [];

    public function __construct(?string $configFile = null)
    {
        $this->setConfigFile($configFile);
        $this->setConfigFile(/** @scrutinizer ignore-type */ $configFile);
        $this->addCompilerPass(new CleanupPass());
    }

    public function setConfigFile(string $configFile): void
    {
        $this->configFile = $configFile;
    }

    protected function addExtension(ExtensionInterface $extension): void
    {
        $this->extensions[] = $extension;
    }

    protected function addCompilerPass(CompilerPassInterface $pass): void
    {
        $this->compilerPasses[] = $pass;
    }

    public function setContainerClassName(string $fqcn): void
    {
        $fqcn = strtr($fqcn, [
            '.' => '\\',
            '/' => '\\',
        ]);
        $pos = strrpos($fqcn, '\\');
        $this->className = substr($fqcn, $pos + 1);
        $this->classNs = substr($fqcn, 0, $pos);
    }

    /**
     * @param array $metadata
     */
    protected function getContainerBuilder(array $metadata = []): ContainerBuilder
    {
        $container = new ContainerBuilder();

        foreach ($this->extensions as $extension) {
            $container->registerExtension($extension);
        }

        foreach ($this->compilerPasses as $pass) {
            $container->addCompilerPass($pass);
        }

        $locator = new FileLocator('.');
        $loaders = [
            new YamlFileLoader($container, $locator),
            new XmlFileLoader($container, $locator),
        ];
        $delegatingLoader = new DelegatingLoader(new LoaderResolver($loaders));
        $delegatingLoader->load($this->configFile);

        // set the production soap metadata
        $container->setParameter('goetas_webservices.soap.metadata', $metadata);

        $container->compile();

        return $container;
    }

    /**
     * @return array
     */
    protected function fetchMetadata(ContainerInterface $debugContainer): array
    {
        $metadataReader = $debugContainer->get('goetas_webservices.soap.metadata_loader.dev');
        $wsdlMetadata = $debugContainer->getParameter('goetas_webservices.soap.config')['metadata'];
        $metadata = [];
        foreach (array_keys($wsdlMetadata) as $uri) {
            $metadata[$uri] = $metadataReader->load($uri);
        }

        return $metadata;
    }

    public function getDebugContainer(): ContainerBuilder
    {
        return $this->getContainerBuilder();
    }

    public function getProdContainer(): ContainerInterface
    {
        $ref = new \ReflectionClass(sprintf('%s\\%s', $this->classNs, $this->className));

        return $ref->newInstance();
    }

    public function dumpContainerForProd(string $dir, ContainerInterface $debugContainer): void
    {
        $metadata = $this->fetchMetadata($debugContainer);

        if (!$metadata) {
            throw new \Exception('Empty metadata can not be used for production');
        }

        $forProdContainer = $this->getContainerBuilder($metadata);
        $this->dump($forProdContainer, $dir);
    }

    private function dump(ContainerBuilder $container, string $dir): void
    {
        $dumper = new PhpDumper($container);
        $options = [
            'debug' => false,
            'class' => $this->className,
            'namespace' => $this->classNs,
        ];

        if (!is_dir($dir)) {
            mkdir($dir, 0777, true);
        }

        file_put_contents($dir . '/' . $this->className . '.php', $dumper->dump($options));
    }

    public static function createSerializerBuilderFromContainer(ContainerInterface $container, ?callable $handlersCallback = null, ?callable $listenersCallback = null, ?string $metadataDirPrefix = null): SerializerBuilder
    {
        $destinations = $container->getParameter('goetas_webservices.soap.config')['destinations_jms'];

        if (null !== $metadataDirPrefix) {
            $destinations = array_map(static function ($dir) use ($metadataDirPrefix) {
                return rtrim($metadataDirPrefix, '/') . '/' . $dir;
            }, $destinations);
        }

        return self::createSerializerBuilder($destinations, $handlersCallback, $listenersCallback);
    }

    /**
     * @param array $jmsMetadata
     */
    public static function createSerializerBuilder(array $jmsMetadata, ?callable $handlersCallback = null, ?callable $listenersCallback = null): SerializerBuilder
    {
        $jmsMetadata = array_merge(self::getMetadataForSoapEnvelope(), $jmsMetadata);

        $serializerBuilder = SerializerBuilder::create();

        $h = new HeaderHandler();
        $serializerBuilder->configureHandlers(static function (HandlerRegistryInterface $handler) use ($handlersCallback, $serializerBuilder, $h): void {
            $serializerBuilder->addDefaultHandlers();
            $handler->registerSubscribingHandler(new BaseTypesHandler()); // XMLSchema List handling
            $handler->registerSubscribingHandler(new XmlSchemaDateHandler()); // XMLSchema date handling
            $handler->registerSubscribingHandler($h);
            if ($handlersCallback) {
                call_user_func($handlersCallback, $handler);
            }
        });

        $serializerBuilder->configureListeners(static function (EventDispatcherInterface $d) use ($serializerBuilder, $h, $listenersCallback): void {
            $serializerBuilder->addDefaultListeners();
            $d->addSubscriber($h);
            if ($listenersCallback) {
                call_user_func($listenersCallback, $d);
            }
        });

        foreach ($jmsMetadata as $php => $dir) {
            $serializerBuilder->addMetadataDir($dir, $php);
        }

        return $serializerBuilder;
    }

    /**
     * @return string[]
     */
    public static function getMetadataForSoapEnvelope(): array
    {
        $ref = new \ReflectionClass(Envelope::class);

        return [
            'GoetasWebservices\SoapServices\Metadata\Envelope\SoapEnvelope12' => dirname($ref->getFileName()) . '/../Resources/metadata/jms12',
            'GoetasWebservices\SoapServices\Metadata\Envelope\SoapEnvelope' => dirname($ref->getFileName()) . '/../Resources/metadata/jms',
        ];
    }
}

goetas-webservices / soap-common

Push — master ( dba7cd...d89126 )

createSerializerBuilderFromContainer() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
