DatasourceConfigurator::generateDatasources() - Code Metrics - Inspection of "18 datasource condition" - khusseini/PimcoreRadBrickBundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — 1.x (#19)

by Khairi
created 2020-04-21 23:27 UTC
DatasourceConfigurator::generateDatasources() A

↳ Parent: DatasourceConfigurator
Complexity

Conditions	3
Paths	3
Size

Total Lines	11
Code Lines	7
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	8
CRAP Score	3
Importance

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

namespace Khusseini\PimcoreRadBrickBundle\Configurator;

use ArrayObject;
use Khusseini\PimcoreRadBrickBundle\ContextInterface;
use Khusseini\PimcoreRadBrickBundle\DatasourceRegistry;
use Khusseini\PimcoreRadBrickBundle\RenderArgument;
use Khusseini\PimcoreRadBrickBundle\RenderArgumentEmitter;
use PHP_CodeSniffer\Config;
use Symfony\Component\OptionsResolver\OptionsResolver;

class DatasourceConfigurator extends AbstractConfigurator
{
    public function preCreateEditables(string $brickName, ConfiguratorData $data): void
    {
        $config = $this->resolveConfig($data->getConfig());
        $context = $data->getContext();
        $contextArray = $context->toArray();

        $brickConfig = $this->resolveBrickconfig($config['areabricks'][$brickName]);
        $registry = new DatasourceRegistry();
        foreach ($brickConfig['datasources'] as $id => $datasourceConfig) {
            $dsId = $datasourceConfig['id'];
            $dataSource = $config['datasources'][$dsId];
            $serviceId = $dataSource['service_id'];
            $serviceObject = null;

            if (\is_string($serviceId)) {
                $serviceObject = $this
                    ->getExpressionWrapper()
                    ->evaluateExpression($serviceId, $contextArray)
                ;
            }

            if (!\is_object($serviceObject)) {
                throw new \InvalidArgumentException(sprintf('Service with id "%s" is not an object. %s given.', $serviceId, \gettype($serviceObject)));
            }

            $dataCall = $registry->createMethodCall(
                $serviceObject,
                $dataSource['method'],
                $dataSource['args']
            );

            $wrappedCall = function () use ($context, $dataCall, $datasourceConfig) {
                return $this->callDatasource($context, $dataCall, $datasourceConfig);
            };

            $registry->add($id, $wrappedCall);
        }

        $data->getContext()->setDatasources($registry);
    }

    /**
     * @param array<string, array<string, mixed>> $config
     *
     * @return mixed
     */
    protected function callDatasource(ContextInterface $context, callable $dataCall, array $config)
    {
        $input = [];
        if (
                isset($config['conditions'])
                && \is_array($config['conditions'])
                && !$this->evaluateConditions($config['conditions'], $context)
        ) {
            return [];
        }

        foreach ($config['args'] as $name => $value) {
            $input[$name] = $this->recurseExpression($value, $context->toArray());
        }

        return $dataCall($input);
    }

    /**
     * @param string[] $conditions
     */
    protected function evaluateConditions(array $conditions, ContextInterface $context): bool
    {
        $result = false;
        $contextArray = $context->toArray();
        foreach ($conditions as $condition) {
            $value = $this->getExpressionWrapper()->evaluateExpression($condition, $contextArray);
            $result = ($value !== $condition) && (bool) $value;
            if (!$result) {
                return $result;
            }
        }

        return $result;
    }

    /**
     * @param mixed                $value
     * @param array<string, mixed> $context
     *
     * @return mixed
     */
    protected function recurseExpression($value, array $context)
    {
        if (\is_string($value)) {
            return $this
                ->getExpressionWrapper()
                ->evaluateExpression($value, $context);
        }

        if (\is_array($value)) {
            foreach ($value as $key => $item) {
                $value[$key] = $this->recurseExpression($item, $context);
            }
        }

        return $value;
    }

    public function generateDatasources(RenderArgumentEmitter $emitter, ConfiguratorData $data): void
    {
        $datasources = $data->getContext()->getDatasources();
        if (!$datasources) {
            return;
        }

        $data = $datasources->executeAll();
        foreach ($data as $name => $value) {
            $argument = new RenderArgument('data', $name, $value);
            $emitter->emitArgument($argument);
        }
    }

    public function doCreateEditables(RenderArgumentEmitter $emitter, string $name, ConfiguratorData $data): void
    {
        if (!$data->getContext()->getDatasources()) {
            return;
        }

        $editable = $data->getConfig();
        if (
            !isset($editable['datasource'])
            || !isset($editable['datasource']['name'])
        ) {
            return;
        }

        $this->generateDatasources($emitter, $data);

        $datasourceName = $editable['datasource']['name'];
        $datasourceIdExpression = @$editable['datasource']['id'];

        if (!$emitter->has($datasourceName)) {
            return;
        }

        $dataArgument = $emitter->get($datasourceName);

        unset($editable['datasource']);
        $items = new ArrayObject();

        foreach ($dataArgument->getValue() as $i => $item) {
            //@codeCoverageIgnoreStart
            if ($datasourceIdExpression) {
                $i = $this
                        ->getExpressionWrapper()
                        ->evaluateExpression($datasourceIdExpression, ['item' => $item]);
            }
            //@codeCoverageIgnoreEnd

            $itemArgument = new RenderArgument('editable', $i, $editable);
            $itemArgument = new RenderArgument('editable', /** @scrutinizer ignore-type */ $i, $editable);
            $items[] = $itemArgument;
        }

        $argument = new RenderArgument(
            'collection',
            $name,
            $items
        );

        $emitter->emitArgument($argument);
    }

    public function supportsEditable(string $editableName, array $config): bool
    {
        return isset($config['datasource']) && isset($config['datasource']['id']);
    }

    public function configureEditableOptions(OptionsResolver $optionsResolver): void
    {
        $optionsResolver->setDefault('datasource', []);
    }

    public function postCreateEditables(string $brickName, ConfiguratorData $data, RenderArgumentEmitter $emitter): void
    {
        $this->generateDatasources($emitter, $data);
    }

    /**
     * @param array<mixed> $config
     *
     * @return array<mixed>
     * @codeCoverageIgnore
     */
    protected function resolveBrickconfig(array $config): array
    {
        $or = new OptionsResolver();
        $or->setDefaults(['datasources' => [], 'editables' => []]);
        $or->setDefined(array_keys($config));

        return $or->resolve($config);
    }

    /**
     * @param array<mixed> $config
     *
     * @return array<mixed>
     * @codeCoverageIgnore
     */
    protected function resolveConfig(array $config): array
    {
        $or = new OptionsResolver();
        $or->setDefaults(['datasources' => [], 'areabricks' => []]);
        $or->setDefined(array_keys($config));

        return $or->resolve($config);
    }
}

khusseini / PimcoreRadBrickBundle

Pull Request — 1.x (#19)

DatasourceConfigurator::generateDatasources() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
